mini_exiftool 2.10.4 → 2.12.0

data/test/helpers_for_test.rb

@@ -1,25 +0,0 @@
-# -- encoding: utf-8 --
-require 'mini_exiftool'
-require 'test/unit'
-require 'fileutils'
-require 'tempfile'
-require 'yaml'
-
-include Test::Unit
-
-module TempfileTest
-  def setup
-    @temp_file = Tempfile.new('test')
-    @temp_filename = @temp_file.path
-    @data_dir = File.dirname(__FILE__) + '/data'
-  end
-
-  def teardown
-    @temp_file.close
-  end
-
-  def assert_md5 md5, filename
-    assert_equal md5,  Digest::MD5.hexdigest(File.read(filename))
-  end
-
-end

data/test/test_bad_preview_ifd.rb

@@ -1,29 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestBadPreviewIFD < TestCase
-
-  include TempfileTest
-
-  def setup
-    super
-    @org_filename = @data_dir + '/Bad_PreviewIFD.jpg'
-    FileUtils.cp @org_filename, @temp_filename
-    @bad_preview_ifd = MiniExiftool.new @temp_filename
-  end
-
-  # Feature request rubyforge [#29587]
-  # Thanks to Michael Grove for reporting
-  def test_m_option
-    title = 'anything'
-    @bad_preview_ifd.title = title
-    assert_equal false, @bad_preview_ifd.save, '-m option seems to be not neccessary'
-    @bad_preview_ifd.reload
-    @bad_preview_ifd.title = title
-    @bad_preview_ifd.ignore_minor_errors = true
-    assert_equal true, @bad_preview_ifd.save, 'Error while saving'
-    @bad_preview_ifd.reload
-    assert_equal title, @bad_preview_ifd.title
-  end
-
-end

data/test/test_class_methods.rb

@@ -1,80 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestClassMethods < TestCase
-
-  def test_new
-    assert_nothing_raised do
-      @mini_exiftool = MiniExiftool.new
-    end
-    assert_equal nil, @mini_exiftool.filename
-    assert_nothing_raised do
-      MiniExiftool.new nil
-    end
-    assert_raises MiniExiftool::Error do
-      MiniExiftool.new false 
-    end
-    assert_raises MiniExiftool::Error do
-      MiniExiftool.new ''
-    end
-    assert_raises MiniExiftool::Error do
-      MiniExiftool.new 'not_existing_file'
-    end
-    assert_raises MiniExiftool::Error do
-      MiniExiftool.new '.' # directory
-    end
-    begin
-      MiniExiftool.new 'not_existing_file'
-    rescue MiniExiftool::Error => e
-      assert_match /File 'not_existing_file' does not exist/, e.message
-    end
-  end
-
-  def test_command
-    cmd = MiniExiftool.command
-    assert_equal 'exiftool', cmd
-    MiniExiftool.command = 'non_existend'
-    assert_equal 'non_existend', MiniExiftool.command
-    assert_raises MiniExiftool::Error do
-      met = MiniExiftool.new(File.join(File.dirname(__FILE__), 
-                                       'data/test.jpg'))
-    end
-    MiniExiftool.command = cmd
-  end
-
-  def test_opts
-    opts = MiniExiftool.opts
-    assert_kind_of Hash, opts
-    begin
-      org = MiniExiftool.opts[:composite]
-      met1 = MiniExiftool.new
-      MiniExiftool.opts[:composite] = !org
-      met2 = MiniExiftool.new
-      MiniExiftool.opts[:composite] = org
-      met3 = MiniExiftool.new
-      assert_equal org, met1.composite
-      assert_equal !org, met2.composite
-      assert_equal org, met1.composite
-    ensure
-      MiniExiftool.opts[:composite] = org
-    end
-  end
-
-  def test_all_tags
-    all_tags = MiniExiftool.all_tags
-    assert all_tags.include?('ISO')
-    assert all_tags.include?('ExifToolVersion')
-  end
-
-  def test_writable_tags
-    w_tags = MiniExiftool.writable_tags
-    assert w_tags.include?('ISO')
-    assert ! w_tags.include?('ExifToolVersion')
-  end
-
-  def test_exiftool_version
-    v = MiniExiftool.exiftool_version
-    assert_match /\A\d+\.\d+\z/, v
-  end
-
-end

data/test/test_composite.rb

@@ -1,19 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestComposite < TestCase
-
-  def setup
-    @data_dir = File.dirname(__FILE__) + '/data'
-    @filename_test = @data_dir + '/test.jpg'
-    @mini_exiftool = MiniExiftool.new @filename_test, :composite => false
-    @mini_exiftool_c = MiniExiftool.new @filename_test
-  end
-
-  def test_composite_tags
-    assert_equal false, @mini_exiftool.tags.include?('Aperture')
-    assert_equal true, @mini_exiftool_c.tags.include?('Aperture')
-    assert_equal 9.5, @mini_exiftool_c['Aperture']
-  end
-
-end

data/test/test_copy_tags_from.rb

@@ -1,55 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestCopyTagsFrom < TestCase
-
-  include TempfileTest
-
-  def setup
-    super
-    @canon_filename = @data_dir + '/Canon.jpg'
-    FileUtils.cp(@canon_filename, @temp_filename)
-    @mini_exiftool = MiniExiftool.new(@temp_filename)
-    @source_filename = @data_dir + '/test.jpg'
-    @canon_md5 = Digest::MD5.hexdigest(File.read(@canon_filename))
-    @source_md5 = Digest::MD5.hexdigest(File.read(@source_filename))
-  end
-
-  def test_single_tag
-    assert_nil @mini_exiftool.title
-    res = @mini_exiftool.copy_tags_from(@source_filename, :title)
-    assert res
-    assert_equal 'Abenddämmerung', @mini_exiftool.title
-    assert_md5 @source_md5, @source_filename
-  end
-
-  def test_more_than_one_tag
-    assert_nil @mini_exiftool.title
-    assert_nil @mini_exiftool.keywords
-    res = @mini_exiftool.copy_tags_from(@source_filename, %w[title keywords])
-    assert res
-    assert_equal 'Abenddämmerung', @mini_exiftool.title
-    assert_equal %w[Orange Rot], @mini_exiftool.keywords
-    assert_md5 @source_md5, @source_filename
-  end
-
-  def test_non_existing_sourcefile
-    assert_raises MiniExiftool::Error do
-      @mini_exiftool.copy_tags_from('non_existend_file', :title)
-    end
-    assert_md5 @source_md5, @source_filename
-  end
-
-  def test_non_existend_tag
-    @mini_exiftool.copy_tags_from(@source_filename, :non_existend_tag)
-    assert_md5 @canon_md5, @canon_filename
-    assert_md5 @source_md5, @source_filename
-  end
-
-  def test_non_writable_tag
-    @mini_exiftool.copy_tags_from(@source_filename, 'JFIF')
-    assert_md5 @canon_md5, @canon_filename
-    assert_md5 @source_md5, @source_filename
-  end
-
-end

data/test/test_dumping.rb

@@ -1,80 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestDumping < TestCase
-
-  def setup
-    @data_dir = File.dirname(__FILE__) + '/data'
-    @filename_test = @data_dir + '/test.jpg'
-    @mini_exiftool = MiniExiftool.new @filename_test
-  end
-
-  def test_to_hash
-    hash = @mini_exiftool.to_hash
-    assert_equal Hash, hash.class
-    assert_equal @mini_exiftool.tags.size, hash.size, 'Size of Hash is not correct.'
-    assert_not_nil hash['ExifToolVersion'], 'Original name of exiftool tag is not preserved.'
-    all_ok = true
-    different_tag = ''
-    v = ''
-    hash.each do |k,v|
-      unless @mini_exiftool[k] == v
-        all_ok = false
-        different_tag = k
-        break
-      end
-    end
-    assert all_ok, "Tag #{different_tag.inspect}: expected: #{@mini_exiftool[different_tag].inspect}, actual: #{v.inspect}"
-  end
-
-  def test_from_hash
-    hash = @mini_exiftool.to_hash
-    mini_exiftool_new = MiniExiftool.from_hash hash
-    assert_equal MiniExiftool, mini_exiftool_new.class
-    assert_equal @mini_exiftool.tags.size, mini_exiftool_new.tags.size
-    all_ok = true
-    different_tag = ''
-    @mini_exiftool.tags.each do |tag|
-      unless @mini_exiftool[tag] == mini_exiftool_new[tag]
-        all_ok = false
-        different_tag = tag
-        break
-      end
-    end
-    assert all_ok, "Tag #{different_tag.inspect}: expected: #{@mini_exiftool[different_tag].inspect}, actual: #{mini_exiftool_new[different_tag].inspect}"
-
-  end
-
-  def test_to_yaml
-    hash = @mini_exiftool.to_hash
-    yaml = @mini_exiftool.to_yaml
-    assert_equal hash, YAML.unsafe_load(yaml)
-  end
-
-  def test_from_yaml
-    hash = @mini_exiftool.to_hash
-    yaml = hash.to_yaml
-    mini_exiftool_new = MiniExiftool.from_yaml(yaml)
-    assert_equal MiniExiftool, mini_exiftool_new.class
-    assert_equal hash, mini_exiftool_new.to_hash
-  end
-
-  def test_heuristics_for_restoring_composite
-    standard = @mini_exiftool.to_hash
-    no_composite = MiniExiftool.new(@filename_test, :composite => false).to_hash
-    assert_equal true, MiniExiftool.from_hash(standard).composite
-    assert_equal false, MiniExiftool.from_hash(no_composite).composite
-    assert_equal true, MiniExiftool.from_yaml(standard.to_yaml).composite
-    assert_equal false, MiniExiftool.from_yaml(no_composite.to_yaml).composite
-  end
-
-  def test_heuristics_for_restoring_numerical
-    standard = @mini_exiftool.to_hash
-    numerical = MiniExiftool.new(@filename_test, :numerical => true).to_hash
-    assert_equal false, MiniExiftool.from_hash(standard).numerical
-    assert_equal true, MiniExiftool.from_hash(numerical).numerical
-    assert_equal false, MiniExiftool.from_yaml(standard.to_yaml).numerical
-    assert_equal true, MiniExiftool.from_yaml(numerical.to_yaml).numerical
-  end
-
-end

data/test/test_encodings.rb

@@ -1,30 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestEncodings < TestCase
-
-  include TempfileTest
-
-  def setup
-    super
-    @data_dir = File.dirname(__FILE__) + '/data'
-    @filename_test = @data_dir + '/test_encodings.jpg'
-    @mini_exiftool = MiniExiftool.new @filename_test
-  end
-
-  def test_iptc_encoding
-    object_name = "Möhre"
-    assert_not_equal object_name, @mini_exiftool.object_name
-    correct_iptc = MiniExiftool.new(@filename_test, iptc_encoding: 'MacRoman')
-    assert_equal object_name, correct_iptc.object_name
-    FileUtils.cp(@filename_test, @temp_filename)
-    correct_iptc_write = MiniExiftool.new(@temp_filename, iptc_encoding: 'MacRoman')
-    caption = 'Das ist eine Möhre'
-    correct_iptc_write.caption_abstract = caption
-    correct_iptc_write.save!
-    correct_iptc_write.reload
-    assert_equal object_name, correct_iptc_write.object_name
-    assert_equal caption, correct_iptc_write.caption_abstract
-  end
-
-end

data/test/test_filename_access.rb

@@ -1,60 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-require 'rbconfig'
-require 'tmpdir'
-
-# Thanks to uwe58 and others for hints
-
-class TestFilenameAccess < TestCase
-
-  @@running_on_windows = /mswin|mingw|cygwin/ === RbConfig::CONFIG['host_os']
-
-  @@fs_enc = Encoding.find('filesystem')
-
-  def create_testfile(basename_new)
-    tmpdir = Dir.tmpdir
-    filename_org = File.join(File.dirname(__FILE__), 'data/test.jpg')
-    filename_new = File.join(tmpdir, basename_new)
-    FileUtils.cp filename_org, filename_new.encode(@@fs_enc)
-    filename_new
-  end
-
-  def do_testing_with(basename)
-    filename_test = create_testfile(basename)
-    # read
-    m = MiniExiftool.new filename_test
-    assert_equal 400, m.iso
-    # save
-    m.iso = 200
-    m.save
-    assert_equal 200, m.iso
-    # Check original filename maybe with other encoding than filesystem
-    assert_equal basename, File.basename(m.filename)
-  rescue Exception => e
-    assert false, "File #{filename_test.inspect} not found!"
-  end
-
-  def test_access_filename_with_spaces
-    do_testing_with 'filename with spaces.jpg'
-  end
-
-  def test_access_filename_with_special_chars
-    do_testing_with 'filename_with_Ümläüts.jpg'
-  end
-
-  unless @@running_on_windows
-    def test_access_filename_with_doublequotes
-      do_testing_with 'filename_with_"doublequotes"_inside.jpg'
-    end
-  end
-
-  def test_access_filename_with_dollar_sign
-    # Thanks to Michael Dungan for the hint
-    do_testing_with 'filename_with_$_sign.jpg'
-  end
-
-  def test_access_filename_with_ampersand
-    do_testing_with 'filename_with_&_sign.jpg'
-  end
-
-end

data/test/test_from_hash.rb

@@ -1,22 +0,0 @@
-require 'helpers_for_test'
-require 'json'
-
-class TestFromHash < TestCase
-  def setup
-    @data_dir = File.dirname(__FILE__) + '/data'
-    hash_data = JSON.parse(File.read( @data_dir + '/test.jpg.json')).first
-    @mini_exiftool = MiniExiftool.from_hash hash_data
-  end
-
-  def test_conversion
-    assert_kind_of String, @mini_exiftool.model
-    assert_kind_of Time, @mini_exiftool['DateTimeOriginal']
-    assert_kind_of Float, @mini_exiftool['MaxApertureValue']
-    assert_kind_of String, @mini_exiftool.flash
-    assert_kind_of Integer, @mini_exiftool['ExposureCompensation']
-    assert_kind_of String, (@mini_exiftool['SubjectLocation'] || @mini_exiftool['SubjectArea'])
-    assert_kind_of Array, @mini_exiftool['Keywords']
-    assert_kind_of String, @mini_exiftool['SupplementalCategories']
-    assert_kind_of Rational, @mini_exiftool.shutterspeed
-  end
-end

data/test/test_instance_methods.rb

@@ -1,24 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestRead < TestCase
-
-  def setup
-    @data_dir = File.dirname(__FILE__) + '/data'
-    @filename_test = @data_dir + '/test.jpg'
-    @mini_exiftool = MiniExiftool.new @filename_test
-  end
-
-  def test_respond_to_missing
-    assert_true @mini_exiftool.respond_to?(:iso), 'instance should respond to iso because it has a value for ISO'
-    assert_true @mini_exiftool.respond_to?('iso'), 'instance should respond to iso because it has a value for ISO'
-    assert_true @mini_exiftool.respond_to?('ISO'), 'instance should respond to ISO because it has a value for ISO'
-    assert_true @mini_exiftool.respond_to?(:iso=), 'instance should respond to iso= because all setters are allowed'
-    assert_true @mini_exiftool.respond_to?('iso='), 'instance should respond to iso= because all setters are allowed'
-    assert_true @mini_exiftool.respond_to?('ISO='), 'instance should respond to ISO= because all setters are allowed'
-    assert_false @mini_exiftool.respond_to?(:comment), 'instance should not respond to comment because it has no value for Comment'
-    assert_false @mini_exiftool.respond_to?('comment'), 'instance should not respond to comment because it has no value for Comment'
-    assert_false @mini_exiftool.respond_to?('Comment'), 'instance should not respond to Comment because it has no value for Comment'
-  end
-
-end

data/test/test_invalid_byte_sequence_in_utf8.rb

@@ -1,29 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-require 'json'
-
-# Thanks to Chris Salzberg (aka shioyama) and
-# Robert May (aka robotmay) for precious hints
-
-class TestInvalidByteSequenceInUtf8 < TestCase
-
-  def setup
-    @json = File.read(File.dirname(__FILE__) + '/data/invalid_byte_sequence_in_utf8.json')
-  end
-
-  def test_invalid_byte_sequence_gets_unconverted_value_with_invalid_encoding
-    omit 'Java version of json gem can not handle invalid encoded data' if RUBY_PLATFORM == 'java'
-    assert_nothing_raised do
-      mini_exiftool = MiniExiftool.from_json(@json)
-      assert_equal 1561, mini_exiftool.color_balance_unknown.size
-    end
-  end
-
-  def test_replace_invalid_chars
-    assert_nothing_raised do
-      mini_exiftool = MiniExiftool.from_json(@json, :replace_invalid_chars => '')
-      assert_equal 1036, mini_exiftool.color_balance_unknown.size
-    end
-  end
-
-end

data/test/test_invalid_rational.rb

@@ -1,13 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestInvalidRational < TestCase
-
-  def test_rescue_from_invalid_rational
-    mini_exiftool = MiniExiftool.from_json(File.read('test/data/invalid_rational.json'))
-    assert_equal '1/0', mini_exiftool.user_comment
-  rescue Exception
-    assert false, 'Tag values of the form x/0 should not raise an Exception.'
-  end
-
-end

data/test/test_io.rb

@@ -1,67 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-require 'stringio'
-
-class TestIo < TestCase
-
-  def test_simple_case
-    io = open_real_io
-    mini_exiftool = MiniExiftool.new(io)
-    assert_equal false, io.closed?, 'IO should not be closed.'
-    assert_equal 400, mini_exiftool.iso
-  end
-
-  def test_non_readable_io
-    assert_raises MiniExiftool::Error do
-      begin
-        MiniExiftool.new($stdout)
-      rescue MiniExiftool::Error => e
-        assert_equal 'IO is not readable.', e.message
-        raise e
-      end
-    end
-  end
-
-  def test_no_writing_when_using_io
-    io = open_real_io
-    m = MiniExiftool.new(io)
-    m.iso = 100
-    assert_raises MiniExiftool::Error do
-      begin
-        m.save
-      rescue MiniExiftool::Error => e
-        assert_equal 'No writing support when using an IO.', e.message
-        raise e
-      end
-    end
-  end
-
-  def test_fast_options
-    $DEBUG = true
-    s = StringIO.new
-    $stderr = s
-    MiniExiftool.new open_real_io
-    s.rewind
-    assert_match /^exiftool -j  "-"$/, s.read
-    s = StringIO.new
-    $stderr = s
-    MiniExiftool.new open_real_io, :fast => true
-    s.rewind
-    assert_match /^exiftool -j -fast  "-"$/, s.read
-    s = StringIO.new
-    $stderr = s
-    MiniExiftool.new open_real_io, :fast2 => true
-    s.rewind
-    assert_match /^exiftool -j -fast2  "-"$/, s.read
-  ensure
-    $DEBUG = false
-    $stderr = STDERR
-  end
-
-  protected
-
-  def open_real_io
-    File.open(File.join(File.dirname(__FILE__), 'data', 'test.jpg'), 'r')
-  end
-
-end

data/test/test_pstore.rb

@@ -1,37 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestPstore < TestCase
-
-  def test_pstore
-    pstore_dir = Dir.mktmpdir
-    writable_tags = MiniExiftool.writable_tags
-    res = execute(pstore_dir)
-    t1 = res['time']
-    assert_equal writable_tags, res['writable_tags']
-    assert_equal 1, Dir[File.join(pstore_dir, '*')].size
-    res = execute(pstore_dir)
-    t2 = res['time']
-    assert_equal writable_tags, res['writable_tags']
-    assert t2 < 1.0, format('loading cached tag information should be done in under 1 second but needed %.2fs', t2)
-    assert 10 * t2 < t1, format('loading cached tag information (%.2fs) should be 10 times faster than loading uncached information (%.2fs)', t2, t1)
-  ensure
-    FileUtils.rm_rf pstore_dir
-  end
-
-  private
-
-  def execute pstore_dir
-    script = <<-END
-      MiniExiftool.pstore_dir = '#{pstore_dir}'
-      res = {}
-      start = Time.now
-      res['writable_tags'] = MiniExiftool.writable_tags
-      res['time'] = Time.now - start
-      puts YAML.dump res
-    END
-    cmd = %Q(#{RUBY_ENGINE} -EUTF-8 -I lib -r mini_exiftool -r yaml -e "#{script}")
-    YAML.unsafe_load(`#{cmd}`)
-  end
-
-end

data/test/test_read.rb

@@ -1,49 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestRead < TestCase
-
-  def setup
-    @data_dir = File.dirname(__FILE__) + '/data'
-    @filename_test = @data_dir + '/test.jpg'
-    @mini_exiftool = MiniExiftool.new @filename_test
-  end
-
-  def test_access
-    assert_equal 'DYNAX 7D', @mini_exiftool['Model']
-    assert_equal 'MLT0', @mini_exiftool['maker_note_version']
-    assert_equal 'MLT0', @mini_exiftool[:MakerNoteVersion]
-    assert_equal 'MLT0', @mini_exiftool[:maker_note_version]
-    assert_equal 'MLT0', @mini_exiftool.maker_note_version
-    assert_equal 400, @mini_exiftool.iso
-  end
-
-  def test_tags
-    assert @mini_exiftool.tags.include?('FileSize')
-  end
-
-  def test_conversion
-    assert_kind_of String, @mini_exiftool.model
-    assert_kind_of Time, @mini_exiftool['DateTimeOriginal']
-    assert_kind_of Float, @mini_exiftool['MaxApertureValue']
-    assert_kind_of String, @mini_exiftool.flash
-    assert_kind_of Integer, @mini_exiftool['ExposureCompensation']
-    assert_kind_of String, (@mini_exiftool['SubjectLocation'] || @mini_exiftool['SubjectArea'])
-    assert_kind_of Array, @mini_exiftool['Keywords']
-    assert_kind_of String, @mini_exiftool['SupplementalCategories']
-    assert_kind_of Rational, @mini_exiftool.shutterspeed
-  end
-
-  def test_list_tags
-    assert_equal ['Orange', 'Rot'], @mini_exiftool['Keywords']
-    assert_equal 'Natur', @mini_exiftool['SupplementalCategories']
-    assert_equal ['Natur'], Array(@mini_exiftool['SupplementalCategories'])
-  end
-
-  def test_value_encoding
-    title= 'Abenddämmerung'
-    assert_equal Encoding::UTF_8, @mini_exiftool.title.encoding
-    assert_equal title, @mini_exiftool.title
-  end
-
-end

data/test/test_read_coordinates.rb

@@ -1,18 +0,0 @@
-# -- encoding: utf-8 --
-require 'helpers_for_test'
-
-class TestReadCoordinates < TestCase
-
-  def setup
-    @data_dir = File.dirname(__FILE__) + '/data'
-    @filename_test = @data_dir + '/test_coordinates.jpg'
-  end
-
-  def test_access_coordinates
-    mini_exiftool_coord = MiniExiftool.new @filename_test, :coord_format => "%.6f degrees"
-    assert_match /^43.653167 degrees/, mini_exiftool_coord['GPSLatitude']
-    assert_match /^79.373167 degrees/, mini_exiftool_coord['GPSLongitude']
-    assert_match /^43.653167 degrees.*, 79.373167 degrees/, mini_exiftool_coord['GPSPosition']
-  end
-
-end