multi_exiftool 0.18.1 → 0.19.0

data/test/test_functional_api.rb

@@ -1,290 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFunctionalApi < Test::Unit::TestCase
-
-  context 'reading' do
-
-    setup do
-      @abc_authors = ['Jan Friedrich'] * 3
-      @abc_fnumbers = [5.6, 6.7, 8]
-      @abc_titles = 'Title A,Title B,Title C'.split(/,/)
-    end
-
-    test 'successful reading only filenames' do
-      run_in_temp_dir do
-        values, errors = MultiExiftool.read(%w(a.jpg b.jpg c.jpg))
-        assert_equal @abc_authors, values.map {|e| e['Author']}
-        assert_equal @abc_fnumbers, values.map {|e| e['FNumber']}
-        assert_equal @abc_titles, values.map {|e| e['Title']}
-        assert_equal [], errors
-      end
-    end
-
-    test 'successful reading with one tag' do
-      run_in_temp_dir do
-        values, errors = MultiExiftool.read(%w(a.jpg b.jpg c.jpg), tags: %w(title))
-        assert_equal @abc_titles, values.map {|e| e['Title']}
-        assert_equal [nil] * 3, values.map {|e| e['Author']}
-        assert_equal [], errors
-      end
-    end
-
-    test 'successful reading of hierarchical data' do
-      run_in_temp_dir do
-        values, errors = MultiExiftool.read(%w(a.jpg), group: 0)
-        res = values.first
-        assert_equal 'a.jpg', res.source_file
-        assert_equal 5.6, res.exif.fnumber
-        assert_equal [], errors
-      end
-    end
-
-    test 'successful reading with numerical option' do
-      run_in_temp_dir do
-        values, errors = MultiExiftool.read(%w[a.jpg b.jpg c.jpg], tags: %w[orientation], numerical: true)
-        assert_equal [1, 2, 3], values.map {|e| e.orientation}
-        assert_equal [], errors
-      end
-    end
-
-    test 'options with boolean argument' do
-      run_in_temp_dir do
-        values, errors = MultiExiftool.read('a.jpg')
-        assert_equal 5.6, values.first.aperture
-        values, errors = MultiExiftool.read('a.jpg', e: true)
-        assert_equal nil, values.first.aperture
-        assert_equal [], errors
-      end
-    end
-
-    test 'successful reading with user defined tags in config file' do
-      run_in_temp_dir do
-        values, errors = MultiExiftool.read(%w[a.jpg b.jpg c.jpg], tags: %w[mybasename fileextension])
-        assert_equal [nil, nil, nil], values.map(&:mybasename)
-        assert_equal [nil, nil, nil], values.map(&:file_extension)
-        assert_equal [], errors
-        values, errors = MultiExiftool.read(%w[a.jpg b.jpg c.jpg], config: 'example.config', tags: %w[mybasename fileextension])
-        assert_equal %w[a b c], values.map(&:mybasename)
-        assert_equal %w[jpg]*3, values.map(&:file_extension)
-        assert_equal [], errors
-      end
-    end
-  end
-
-  context 'writing' do
-
-    setup do
-      @filenames = %w(a.jpg b.jpg c.jpg)
-    end
-
-    test 'simple case' do
-      run_in_temp_dir do
-        values = {comment: 'foo'}
-        errors = MultiExiftool.write(@filenames, values)
-        assert errors.empty?
-        values, _errors = MultiExiftool.read(@filenames)
-        assert_equal %w(foo) * 3, values.map {|e| e.comment}
-      end
-    end
-
-    test 'tags with spaces in values' do
-      run_in_temp_dir do
-        values = {author: 'Mister X'}
-        errors = MultiExiftool.write(@filenames, values)
-        assert errors.empty?
-        values, _errors = MultiExiftool.read(@filenames)
-        assert_equal ['Mister X'] * 3, values.map {|e| e.author}
-      end
-    end
-
-    test 'tags with rational value' do
-      run_in_temp_dir do
-        values ={exposuretime: Rational(1, 125)}
-        errors = MultiExiftool.write(@filenames, values)
-        assert errors.empty?
-        values, _errors = MultiExiftool.read(@filenames)
-        assert_equal [Rational(1, 125)] * 3, values.map {|e| e.exposuretime}
-      end
-    end
-
-    test 'tags with array-like values' do
-      run_in_temp_dir do
-        keywords = ['one', 'two', 'and three']
-        values = {keywords: keywords}
-        errors = MultiExiftool.write('a.jpg', values)
-        assert errors.empty?
-        values, _errors = MultiExiftool.read('a.jpg')
-        assert_equal keywords, values.first.keywords
-      end
-    end
-
-    test 'options with boolean argument' do
-      run_in_temp_dir do
-        values = {comment: 'foo'}
-        options = {overwrite_original: true}
-        errors = MultiExiftool.write(@filenames, values, options)
-        assert errors.empty?
-        assert_equal [], Dir['*_original']
-      end
-    end
-
-    test 'numerical flag' do
-      run_in_temp_dir do
-        values = {orientation: 2}
-        errors = MultiExiftool.write(@filenames, values)
-        assert_equal ["Warning: Can't convert IFD0:Orientation (matches more than one PrintConv)"], errors
-        errors = MultiExiftool.write(@filenames, values, numerical: true)
-        assert errors.empty?
-      end
-    end
-
-  end
-
-  context 'deleting' do
-
-    setup do
-      @filenames = %w(a.jpg b.jpg c.jpg)
-    end
-
-    test 'delete all values' do
-      run_in_temp_dir do
-        errors = MultiExiftool.delete_values(@filenames)
-        assert_equal [], errors
-        values, errors = MultiExiftool.read(@filenames)
-        assert_equal [nil, nil, nil], values.map {|e| e['Author']}
-        assert_equal [nil, nil, nil], values.map {|e| e['FNumber']}
-        assert_equal [nil, nil, nil], values.map {|e| e['Title']}
-        assert_equal [], errors
-      end
-    end
-
-    test 'delete values for some tags' do
-      run_in_temp_dir do
-        errors = MultiExiftool.delete_values(@filenames, tags: %w(author title))
-        assert_equal [], errors
-        values, errors = MultiExiftool.read(@filenames)
-        assert_equal [nil, nil, nil], values.map {|e| e['Author']}
-        assert_equal [5.6, 6.7, 8], values.map {|e| e['FNumber']}
-        assert_equal [nil, nil, nil], values.map {|e| e['Title']}
-        assert_equal [], errors
-      end
-    end
-
-    test 'delete values for one tag' do
-      run_in_temp_dir do
-        errors = MultiExiftool.delete_values(@filenames, tags: :title)
-        assert_equal [], errors
-        values, errors = MultiExiftool.read(@filenames)
-        assert_equal ['Jan Friedrich'] * 3, values.map {|e| e['Author']}
-        assert_equal [5.6, 6.7, 8], values.map {|e| e['FNumber']}
-        assert_equal [nil, nil, nil], values.map {|e| e['Title']}
-        assert_equal [], errors
-      end
-    end
-
-    test 'error if tags do not exist' do
-      run_in_temp_dir do
-        errors = MultiExiftool.delete_values(@filenames, tags: %w[foo bar])
-        err1, err2 = errors
-        expected1 = /^Warning: Tag 'foo' is not defined$/
-        expected2 = /^Warning: Tag 'bar' is not defined$/
-        assert_match expected1, err1
-        assert_match expected2, err2
-      end
-    end
-
-  end
-
-  context 'batch' do
-
-    setup do
-      @filenames = %w(a.jpg b.jpg c.jpg)
-      @multiple_values = @filenames.map do |fn|
-        {author: 'Jan Friedrich', comment: "Comment for file #{fn}"}
-      end
-    end
-
-    context 'instance_exec' do
-
-      test 'only filenames and values' do
-        run_in_temp_dir do
-          filenames = @filenames
-          multiple_values = @multiple_values
-          errors = MultiExiftool.batch do
-            filenames.zip multiple_values do |filename, values|
-              write filename, values
-            end
-          end
-          assert_equal [], errors
-          values, errors = MultiExiftool.read(@filenames)
-          assert_equal ['Jan Friedrich'] * 3, values.map {|e| e['Author']}
-          assert_equal ['Comment for file a.jpg', 'Comment for file b.jpg', 'Comment for file c.jpg'], values.map {|e| e['Comment']}
-          assert_equal [], errors
-          assert_equal 3, Dir['*_original'].size
-        end
-      end
-
-      test 'options with boolean argument' do
-        run_in_temp_dir do
-          filenames = @filenames
-          multiple_values = @multiple_values
-          options = {overwrite_original: true}
-          errors = MultiExiftool.batch do
-            filenames.zip multiple_values do |filename, values|
-              write filename, values, options
-            end
-          end
-          assert_equal [], errors
-          values, errors = MultiExiftool.read(@filenames)
-          assert_equal ['Jan Friedrich'] * 3, values.map {|e| e['Author']}
-          assert_equal ['Comment for file a.jpg', 'Comment for file b.jpg', 'Comment for file c.jpg'], values.map {|e| e['Comment']}
-          assert_equal [], errors
-          assert_equal [], Dir['*_original']
-        end
-      end
-
-    end
-
-    context 'yield' do
-
-      test 'only filenames and values' do
-        run_in_temp_dir do
-          errors = MultiExiftool.batch do |batch|
-            @filenames.zip @multiple_values do |filename, values|
-              batch.write filename, values
-            end
-          end
-          assert_equal [], errors
-          values, errors = MultiExiftool.read(@filenames)
-          assert_equal ['Jan Friedrich'] * 3, values.map {|e| e['Author']}
-          assert_equal ['Comment for file a.jpg', 'Comment for file b.jpg', 'Comment for file c.jpg'], values.map {|e| e['Comment']}
-          assert_equal [], errors
-          assert_equal 3, Dir['*_original'].size
-        end
-      end
-
-      test 'options with boolean argument' do
-        run_in_temp_dir do
-          options = {overwrite_original: true}
-          errors = MultiExiftool.batch do |batch|
-            @filenames.zip @multiple_values do |filename, values|
-              batch.write filename, values, options
-            end
-          end
-          assert_equal [], errors
-          values, errors = MultiExiftool.read(@filenames)
-          assert_equal ['Jan Friedrich'] * 3, values.map {|e| e['Author']}
-          assert_equal ['Comment for file a.jpg', 'Comment for file b.jpg', 'Comment for file c.jpg'], values.map {|e| e['Comment']}
-          assert_equal [], errors
-          assert_equal [], Dir['*_original']
-        end
-      end
-
-    end
-
-  end
-
-end

data/test/test_reader.rb

@@ -1,168 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestReader < Test::Unit::TestCase
-
-  MANDATORY_ARGS = MultiExiftool::Reader.mandatory_args
-
-  setup do
-    @reader = MultiExiftool::Reader.new
-  end
-
-  context 'tags' do
-
-    test 'tags are initialized as array' do
-      assert_equal [], @reader.tags
-    end
-
-    test 'tags could be set as single value' do
-      @reader.tags = 'fnumber'
-      assert_equal ['fnumber'], @reader.tags
-    end
-
-  end
-
-  context 'exiftool_args method' do
-
-    test 'simple case' do
-      @reader.filenames = %w(a.jpg b.jpg c.jpg)
-      exiftool_args = MANDATORY_ARGS + %w(a.jpg b.jpg c.jpg)
-      assert_equal exiftool_args, @reader.exiftool_args
-    end
-
-    test 'no filenames' do
-      assert_raises MultiExiftool::Error do
-        @reader.exiftool_args
-      end
-      @reader.filenames = []
-      assert_raises MultiExiftool::Error do
-        @reader.exiftool_args
-      end
-    end
-
-    test 'one filename as string' do
-      @reader.filenames = 'a.jpg'
-      exiftool_args = MANDATORY_ARGS + %w(a.jpg)
-      assert_equal exiftool_args, @reader.exiftool_args
-    end
-
-    test 'filenames with spaces' do
-      @reader.filenames = ['one file with spaces.jpg', 'another file with spaces.tif']
-      exiftool_args = MANDATORY_ARGS + ['one file with spaces.jpg', 'another file with spaces.tif']
-      assert_equal exiftool_args, @reader.exiftool_args
-    end
-
-    test 'tags' do
-      @reader.filenames = %w(a.jpg b.jpg c.jpg)
-      @reader.tags = %w(author fnumber)
-      exiftool_args = MANDATORY_ARGS + %w(-author -fnumber a.jpg b.jpg c.jpg)
-      assert_equal exiftool_args, @reader.exiftool_args
-    end
-
-    test 'options with boolean argument' do
-      @reader.filenames = %w(a.jpg b.jpg c.jpg)
-      @reader.options = {e: true}
-      exiftool_args = MANDATORY_ARGS + %w(-e a.jpg b.jpg c.jpg)
-      assert_equal exiftool_args, @reader.exiftool_args
-    end
-
-    test 'options with value argument' do
-      @reader.filenames = %w(a.jpg b.jpg c.jpg)
-      @reader.options = {lang: 'de'}
-      exiftool_args = MANDATORY_ARGS + %w(-lang de a.jpg b.jpg c.jpg)
-      assert_equal exiftool_args, @reader.exiftool_args
-    end
-
-    test 'numerical flag' do
-      @reader.filenames = %w(a.jpg b.jpg c.jpg)
-      @reader.numerical = true
-      exiftool_args = MANDATORY_ARGS + %w(-n a.jpg b.jpg c.jpg)
-      assert_equal exiftool_args, @reader.exiftool_args
-    end
-
-    test 'group flag' do
-      @reader.filenames = %w(a.jpg)
-      @reader.group = 0
-      exiftool_args = MANDATORY_ARGS + %w(-g0 a.jpg)
-      assert_equal exiftool_args, @reader.exiftool_args
-      @reader.group = 1
-      exiftool_args = MANDATORY_ARGS + %w(-g1 a.jpg)
-      assert_equal exiftool_args, @reader.exiftool_args
-    end
-
-  end
-
-  context 'read method' do
-
-    test 'try to read a non-existing file' do
-      run_in_temp_dir do
-        @reader.filenames = %w(non_existing_file)
-        res = @reader.read
-        assert_equal [], res
-        assert_equal ['Error: File not found - non_existing_file'], @reader.errors
-      end
-    end
-
-    test 'read from an existing and a non-existing file' do
-      run_in_temp_dir do
-        @reader.filenames = %w(a.jpg xxx)
-        @reader.tags = %w(fnumber foo)
-        res = @reader.read
-        assert_equal [5.6], res.map {|e| e['FNumber']}
-        assert_equal ['Error: File not found - xxx'], @reader.errors
-      end
-    end
-
-    test 'successful reading with one tag' do
-      run_in_temp_dir do
-        @reader.filenames = %w(a.jpg b.jpg c.jpg)
-        @reader.tags = %w(fnumber)
-        res =  @reader.read
-        assert_equal [5.6, 6.7, 8], res.map {|e| e['FNumber']}
-        assert_equal %w(SourceFile FNumber), res.first.tags
-        assert_equal [], @reader.errors
-      end
-    end
-
-    test 'successful reading with one tag as symbol' do
-      run_in_temp_dir do
-        @reader.filenames = %w(a.jpg b.jpg c.jpg)
-        @reader.tags = :fnumber
-        res =  @reader.read
-        assert_equal [5.6, 6.7, 8], res.map {|e| e.fnumber}
-        assert_equal %w(SourceFile FNumber), res.first.tags
-        assert_equal [], @reader.errors
-      end
-    end
-
-    test 'successful reading of hierarichal data' do
-      run_in_temp_dir do
-        @reader.filenames = %w(a.jpg)
-        @reader.tags = %w(fnumber)
-        @reader.group = 0
-        res =  @reader.read.first
-        assert_equal 'a.jpg', res.source_file
-        assert_equal 5.6, res.exif.fnumber
-        assert_equal [], @reader.errors
-      end
-    end
-
-    test 'successful reading with user defined tags in config file' do
-      run_in_temp_dir do
-        @reader.filenames = %w(a.jpg b.jpg c.jpg)
-        @reader.tags = %w[mybasename]
-        res = @reader.read
-        assert_equal [nil, nil, nil], res.map(&:mybasename)
-        assert_equal [], @reader.errors
-        @reader.config = 'example.config'
-        res = @reader.read
-        assert_equal %w[a b c], res.map(&:mybasename)
-        assert_equal [], @reader.errors
-      end
-    end
-
-  end
-
-end

data/test/test_values.rb

@@ -1,202 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-require_relative 'helper'
-require 'date'
-
-class TestValues < Test::Unit::TestCase
-
-  context 'value access' do
-
-    setup do
-      hash = {'FNumber' => 8, 'Author' => 'janfri'}
-      @values = MultiExiftool::Values.new(hash)
-    end
-
-    test 'original spelling of tag name' do
-      assert_equal 8, @values['FNumber']
-    end
-
-    test 'variant spellings of tag names' do
-      assert_equal 8, @values['fnumber']
-      assert_equal 8, @values['f_number']
-      assert_equal 8, @values['f-number']
-    end
-
-    test 'tag access via methods' do
-      assert_equal 8, @values.fnumber
-      assert_equal 8, @values.f_number
-    end
-
-  end
-
-  context 'parsing of values' do
-
-    context 'timestamps' do
-
-      setup do
-        hash = {
-          'TimestampWithoutSeconds' => '2009:08:25 12:35',
-          'Timestamp' => '2009:08:25 12:35:42',
-          'TimestampWithFraction' => '2009:08:25 12:35:42.123',
-          'TimestampWithPositiveZone' => '2009:08:26 20:22:24+05:00',
-          'TimestampWithNegativeZone' => '2009:08:26 20:22:24-07:00',
-          'TimestampWithFractionAndZone' => '2016:07:23 15:40:55.123+02:00',
-          'TimestampWithZoneAndDST' => '2016:07:23 15:40:55+02:00 DST',
-          'TimestampWithZ' => '2017:04:08 17:57:27Z',
-          'TimestampWithFractionAndZ' => '2017:04:08 17:57:27.123Z'
-        }
-        @values = MultiExiftool::Values.new(hash)
-      end
-
-      test 'local Time object' do
-        time = Time.local(2009, 8, 25, 12, 35)
-        assert_equal time, @values['TimestampWithoutSeconds']
-        time = Time.local(2009, 8, 25, 12, 35, 42)
-        assert_equal time, @values['Timestamp']
-        time = Time.local(2009, 8, 25, 12, 35, 42.123)
-        assert_equal time, @values['TimestampWithFraction']
-      end
-
-      test 'Time object with given zone' do
-        time = Time.new(2009, 8, 26, 20, 22, 24, '+05:00')
-        values_time = @values['TimestampWithPositiveZone']
-        assert_equal time, values_time
-        assert_equal 5 * 3600, values_time.utc_offset
-        time = Time.new(2009, 8, 26, 20, 22, 24, '-07:00')
-        values_time = @values['TimestampWithNegativeZone']
-        assert_equal time, values_time
-        assert_equal -7 * 3600, values_time.utc_offset
-        time = Time.new(2016, 7, 23, 15, 40, 55.123,'+02:00')
-        values_time = @values['TimestampWithFractionAndZone']
-        assert_equal time, values_time
-      end
-
-      test 'Time object with zone and DST' do
-        time = Time.new(2016, 7, 23, 15, 40, 55,'+02:00')
-        values_time = @values['TimestampWithZoneAndDST']
-        assert_equal time, values_time
-      end
-
-      test 'Time object with UTC zone' do
-        time = Time.new(2017, 4, 8, 17, 57, 27, '+00:00')
-        values_time = @values['TimestampWithZ']
-        assert_equal time, values_time
-        assert_equal 0, values_time.utc_offset
-        time = Time.new(2017, 4, 8, 17, 57, 27.123, '+00:00')
-        values_time = @values['TimestampWithFractionAndZ']
-        assert_equal time, values_time
-        assert_equal 0, values_time.utc_offset
-      end
-
-    end
-
-    context 'other values' do
-
-      setup do
-        hash = {
-          'ShutterSpeed' => '1/200',
-          'PartOfSet' => '1/2',
-          'Track' => '1/5'
-        }
-        @values = MultiExiftool::Values.new(hash)
-      end
-
-      test 'rational values' do
-        assert_equal Rational(1, 200), @values['ShutterSpeed']
-      end
-
-      test 'no rational conversion' do
-        assert_equal '1/2', @values['PartOfSet']
-        assert_equal '1/5', @values['Track']
-      end
-
-    end
-
-    context 'invalid values' do
-
-      test 'timestamp with only zeros' do
-        values = MultiExiftool::Values.new('TimeWithOnlyZeros' => '0000:00:00 00:00:00')
-        assert_nil values['TimeWithOnlyZeros']
-      end
-
-      test 'timestamp with invalid data' do
-        ts =  '2022:25:01 16:25'
-        values = MultiExiftool::Values.new('InvalidTimestamp' => ts)
-        assert_equal ts, values['InvalidTimestamp']
-      end
-
-      test 'rational with denominator zero' do
-        values = MultiExiftool::Values.new('DenominatorZero' => '1/0')
-        assert_equal '1/0', values['DenominatorZero']
-      end
-
-    end
-
-  end
-
-  context 'has_tag?' do
-    setup do
-      @hash = {'FNumber' => 8, 'Author' => 'janfri', 'E-MailAddress' => 'janfri26@gmail.com', 'DateTimeOriginal' => '2018:08:22 11:50:00'}
-      @values = MultiExiftool::Values.new(@hash)
-    end
-
-    test 'different formats as string' do
-      @hash.keys.each do |k|
-        assert_equal true, @values.has_tag?(k)
-      end
-    end
-
-    test 'different formats as symbol' do
-      @hash.keys.each do |k|
-        assert_equal true, @values.has_tag?(k.to_sym)
-      end
-    end
-
-    test 'non existent key' do
-      ['iso', 'ISO', :iso, :ISO].each do |t|
-        assert_equal false, @values.has_tag?(t)
-      end
-    end
-  end
-
-  context 'tags and to_h' do
-
-    setup do
-      @hash = {'FNumber' => 8, 'Author' => 'janfri', 'E-MailAddress' => 'janfri26@gmail.com', 'DateTimeOriginal' => '2017:02:20 21:07:00'}
-      @values = MultiExiftool::Values.new(@hash)
-    end
-
-    test 'tags preserves the original tag names' do
-      assert_equal @hash.keys, @values.tags.to_a
-    end
-
-    test 'to_h preserves original tag names but uses converted values' do
-      dto = Time.new(2017, 2, 20, 21, 7, 0)
-      @hash['DateTimeOriginal'] = dto
-      assert_equal @hash, @values.to_h
-    end
-
-  end
-
-  context 'respond_to_missing?' do
-
-    setup do
-      hash = {'FNumber' => 8, 'Author' => 'janfri'}
-      @values = MultiExiftool::Values.new(hash)
-    end
-
-    test 'existing keys' do
-      [:fnumber, :f_number, :FNumber, 'fnumber', 'f_number', 'FNumber', :author, :Author, 'author', 'Author'].each do |t|
-        assert_equal true, @values.respond_to?(t)
-      end
-    end
-
-    test 'non existing key' do
-      ['iso', 'ISO', :iso, :ISO].each do |t|
-        assert_equal false, @values.respond_to?(t)
-      end
-    end
-
-  end
-end