exiftool 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 97cc49e13b847ed687dca2430f6e3974d1327998
+  data.tar.gz: 7a6c7e780ad4962983b491c517d2f4a8a890264b
+SHA512:
+  metadata.gz: 614fee303365b7d799ebf3d29109502194ed89f35685f4dfabe45a729fd184a23e3d657bc4c91270e5c9ffdda7873f613956c4fa511bfa067f52996500f93f28
+  data.tar.gz: 97ad66d4cab65ea08313ae3b24222852ab9477113deb276eecb88dbda568d59833ddcd164485a5d68857cbca6393729443ddd792d9924d136785c4d1873136f9

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+script: bundle exec rake
+before_install:
+  - sudo apt-get install libimage-exiftool-perl
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - rbx-19mode
+  - jruby-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in exiftoolr.gemspec
+gemspec

data/README.md

@@ -0,0 +1,113 @@
+# Ruby wrapper for ExifTool
+
+[![Build Status](https://secure.travis-ci.org/mceachen/exiftool.png?branch=master)](http://travis-ci.org/mceachen/exiftool)
+[![Gem Version](https://badge.fury.io/rb/exiftool.png)](http://rubygems.org/gems/exiftool)
+[![Code Climate](https://codeclimate.com/github/mceachen/exiftool.png)](https://codeclimate.com/github/mceachen/exiftool)
+
+This gem is the simplest thing that could possibly work that
+reads the output of [exiftool](http://www.sno.phy.queensu.ca/~phil/exiftool)
+and renders it into a ruby hash, with correctly typed values and symbolized keys.
+
+Rubies 1.9 and later are supported.
+
+## Features
+
+* GPS latitude and longitude values are parsed as signed floats,
+  where north and east are positive, and west and south are negative.
+* Values like shutter speed and exposure time are rendered as Rationals,
+  which lets the caller show them as fractions (1/250) or as comparable numeric instances.
+* String values like "interop" and "serial number" are kept as strings
+  (which preserves zero prefixes)
+* Timestamps are attempted to be interpreted with correct timezones and sub-second resolution, if
+  the header contains that data.
+  Please note that EXIF headers don't always include a timezone offset, so we just adopt the system
+  timezone, which may, of course, be wrong.
+* No method_missing madness
+
+## Usage
+
+```ruby
+require 'Exiftool'
+e = Exiftool.new("path/to/iPhone 4S.jpg")
+e.to_hash
+# => {:make => "Apple", :gps_longitude => -122.47566667, …
+e.to_display_hash
+# => {"Make" => "Apple", "GPS Longitude" => -122.47566667, …
+```
+
+### Multiple file support
+
+This gem supports Exiftool's multiget, which lets you fetch metadata for many files at once.
+
+This can be dramatically more efficient (like, 60x faster) than spinning up the ```exiftool```
+process for each file.
+
+Supply an array to the Exiftool initializer, then use ```.result_for```:
+
+```ruby
+require 'Exiftool'
+e = Exiftool.new(Dir["**/*.jpg"])
+result = e.result_for("path/to/iPhone 4S.jpg")
+result.to_hash
+# => {:make => "Apple", :gps_longitude => -122.47566667, …
+result[:gps_longitude]
+# => -122.47566667
+
+e.files_with_results
+# => ["path/to/iPhone 4S.jpg", "path/to/Droid X.jpg", …
+```
+
+### When things go wrong
+
+* ```Exiftool::NoSuchFile``` is raised if the provided filename doesn't exist.
+* ```Exiftool::ExiftoolNotInstalled``` is raised if ```exiftool``` isn't in your ```PATH```.
+* If ExifTool has a problem reading EXIF data, no exception is raised, but ```#errors?``` will return true:
+
+```ruby
+Exiftool.new("Gemfile").errors?
+#=> true
+```
+
+## Installation
+
+First [install ExifTool](http://www.sno.phy.queensu.ca/~phil/exiftool/install.html).
+
+Then, add this your Gemfile:
+
+    gem 'exiftool'
+
+and then run ```bundle```.
+
+## Change history
+
+### 0.2.0
+
+* Renamed from exiftoolr to exiftool
+
+### 0.1.0
+
+* Better timestamp parsing—now both sub-second and timezone offsets are handled correctly
+* Switched to minitest-spec
+* Ruby 1.8.7 is no longer supported, hence the minor version uptick.
+
+### 0.0.9
+
+* Explicitly added MIT licensing to the gemspec.
+
+### 0.0.8
+
+* Extracted methods in parsing to make the code complexity lower. FOUR DOT OH GPA
+
+### 0.0.7
+
+* Added warning values for EXIF headers that are corrupt
+* Made initialize gracefully accept an empty array, or an array of Pathname instances
+* Added support for ruby 1.9.3 and exiftool v8.15 (Ubuntu Natty) and v8.85 (current stable version)
+
+### 0.0.5
+
+Fixed homepage URL in gemspec
+
+### 0.0.4
+
+Added support for multiple file fetching (which is *much* faster for large directories)

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb', 'README.md']
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.libs.push "test"
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task :default => :test

data/exiftool.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'exiftool/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'exiftool'
+  spec.version     = Exiftool::VERSION
+  spec.authors     = ['Matthew McEachen']
+  spec.email       = %w(matthew-github@mceachen.org)
+  spec.homepage    = 'https://github.com/mceachen/exiftoolr'
+  spec.summary     = %q{Multiget ExifTool wrapper for ruby}
+  spec.description = %q{Multiget ExifTool wrapper for ruby}
+  spec.license     = 'MIT'
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.requirements << 'ExifTool (see http://www.sno.phy.queensu.ca/~phil/exiftool/)'
+
+  spec.add_dependency 'json'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-great_expectations'
+  spec.add_development_dependency 'minitest-reporters' unless ENV['CI']
+end

data/lib/exiftool.rb

@@ -0,0 +1,73 @@
+require 'json'
+require 'shellwords'
+require 'exiftool/result'
+
+class Exiftool
+  class NoSuchFile < StandardError ; end
+  class NotAFile < StandardError ; end
+  class ExiftoolNotInstalled < StandardError ; end
+
+  def self.exiftool_installed?
+    exiftool_version > 0
+  end
+
+  def self.exiftool_version
+    @@exiftool_version ||= `exiftool -ver 2> /dev/null`.to_f
+  end
+
+  def self.expand_path(filename)
+    raise(NoSuchFile, filename) unless File.exist?(filename)
+    raise(NotAFile, filename) unless File.file?(filename)
+    File.expand_path(filename)
+  end
+
+  def initialize(filenames, exiftool_opts = '')
+    @file2result = {}
+    filenames = [filenames] if filenames.is_a?(String)
+    unless filenames.empty?
+      escaped_filenames = filenames.collect do |f|
+        Shellwords.escape(self.class.expand_path(f.to_s))
+      end.join(" ")
+      # I'd like to use -dateformat, but it doesn't support timezone offsets properly,
+      # nor sub-second timestamps.
+      cmd = "exiftool #{exiftool_opts} -j -coordFormat \"%.8f\" #{escaped_filenames} 2> /dev/null"
+      json = `#{cmd}`
+      raise ExiftoolNotInstalled if json == ""
+      JSON.parse(json).each do |raw|
+        result = Result.new(raw)
+        @file2result[result.source_file] = result
+      end
+    end
+  end
+
+  def result_for(filename)
+    @file2result[self.class.expand_path(filename)]
+  end
+
+  def files_with_results
+    @file2result.values.collect { |r| r.source_file unless r.errors? }.compact
+  end
+
+  def to_hash
+    first.to_hash
+  end
+
+  def to_display_hash
+    first.to_display_hash
+  end
+
+  def symbol_display_hash
+    first.symbol_display_hash
+  end
+
+  def errors?
+    @file2result.values.any? { |ea| ea.errors? }
+  end
+
+  private
+
+  def first
+    raise InvalidArgument, 'use #result_for when multiple filenames are used' if @file2result.size > 1
+    @file2result.values.first
+  end
+end

data/lib/exiftool/parser.rb

@@ -0,0 +1,62 @@
+require 'time'
+require 'rational'
+
+class Exiftool
+  class Parser
+
+    WORD_BOUNDARY_RES = [/([A-Z\d]+)([A-Z][a-z])/, /([a-z\d])([A-Z])/]
+    FRACTION_RE = /^(\d+)\/(\d+)$/
+
+    attr_reader :key, :display_key, :sym_key, :raw_value
+
+    def initialize(key, raw_value)
+      @key = key
+      @display_key = WORD_BOUNDARY_RES.inject(key) { |k, regex| k.gsub(regex, '\1 \2') }
+      @sym_key = display_key.downcase.gsub(' ', '_').to_sym
+      @raw_value = raw_value
+    end
+
+    def value
+      for_lat_long ||
+        for_date ||
+        for_fraction ||
+        raw_value
+    rescue StandardError => e
+      "Warning: Parsing '#{raw_value}' for attribute '#{key}' raised #{e.message}"
+    end
+
+    private
+
+    def for_lat_long
+      if sym_key == :gps_latitude || sym_key == :gps_longitude
+        value, direction = raw_value.split(" ")
+        if value =~ /\A\d+\.?\d*\z/
+          value.to_f * (['S', 'W'].include?(direction) ? -1 : 1)
+        end
+      end
+    end
+
+    def for_date
+      if raw_value.is_a?(String) && display_key =~ /\bdate\b/i
+        try_parse { Time.strptime(raw_value, '%Y:%m:%d %H:%M:%S%z') } ||
+          try_parse { Time.strptime(raw_value, '%Y:%m:%d %H:%M:%S') } ||
+          try_parse { Time.strptime(raw_value, '%Y:%m:%d %H:%M:%S.%L%z') } ||
+          try_parse { Time.strptime(raw_value, '%Y:%m:%d %H:%M:%S.%L') } ||
+          try_parse { Time.parse(raw_value) }
+      end
+    end
+
+    def try_parse
+      yield
+    rescue ArgumentError
+      nil
+    end
+
+    def for_fraction
+      if raw_value.is_a?(String)
+        scan = raw_value.scan(FRACTION_RE).first
+        v = Rational(*scan.map { |ea| ea.to_i }) unless scan.nil?
+      end
+    end
+  end
+end

data/lib/exiftool/result.rb

@@ -0,0 +1,32 @@
+require 'exiftool/parser'
+
+class Exiftool
+  class Result
+    attr_reader :to_hash, :to_display_hash, :symbol_display_hash
+
+    def initialize(raw_hash)
+      @raw_hash = raw_hash
+      @to_hash = {}
+      @to_display_hash = {}
+      @symbol_display_hash = {}
+      @raw_hash.each do |key, raw_value|
+        p = Parser.new(key, raw_value)
+        @to_hash[p.sym_key] = p.value
+        @to_display_hash[p.display_key] = p.value
+        @symbol_display_hash[p.sym_key] = p.display_key
+      end
+    end
+
+    def [](key)
+      @to_hash[key]
+    end
+
+    def source_file
+      self[:source_file]
+    end
+
+    def errors?
+      self[:error] == 'Unknown file type' || self[:warning] == 'Unsupported file type'
+    end
+  end
+end

data/lib/exiftool/version.rb

@@ -0,0 +1,3 @@
+class Exiftool
+  VERSION = Gem::Version.new('0.2.0')
+end

data/test/Canon 20D.jpg.yaml

@@ -0,0 +1,225 @@
+---
+:source_file: /Users/mrm/Dropbox/code/exiftoolr/test/Canon 20D.jpg
+:exif_tool_version: 9.31
+:file_name: Canon 20D.jpg
+:directory: /Users/mrm/Dropbox/code/exiftoolr/test
+:file_size: 2.9 MB
+:file_modify_date: 2012-02-23 05:22:17.000000000 +00:00
+:file_access_date: 2013-07-14 20:25:41.000000000 +00:00
+:file_inode_change_date: 2013-02-16 19:21:59.000000000 +00:00
+:file_permissions: rw-r--r--
+:file_type: JPEG
+:mime_type: image/jpeg
+:exif_byte_order: Little-endian (Intel, II)
+:make: Canon
+:model: Canon EOS 20D
+:orientation: Horizontal (normal)
+:x_resolution: 72
+:y_resolution: 72
+:resolution_unit: inches
+:modify_date: 2004-09-19 12:25:20.000000000 +00:00
+:y_cb_cr_positioning: Co-sited
+:exposure_time: !ruby/object:Rational
+  denominator: 250
+  numerator: 1
+:f_number: 9.0
+:exposure_program: Program AE
+:iso: 200
+:exif_version: '0221'
+:date_time_original: 2004-09-19 12:25:20.000000000 +00:00
+:create_date: 2004-09-19 12:25:20.000000000 +00:00
+:components_configuration: Y, Cb, Cr, -
+:shutter_speed_value: !ruby/object:Rational
+  denominator: 250
+  numerator: 1
+:aperture_value: 9.0
+:flash: Off, Did not fire
+:focal_length: 85.0 mm
+:macro_mode: Normal
+:self_timer: 'Off'
+:quality: Fine
+:canon_flash_mode: 'Off'
+:continuous_drive: Single
+:focus_mode: One-shot AF
+:record_mode: JPEG
+:canon_image_size: Large
+:easy_mode: Manual
+:digital_zoom: None
+:contrast: '+1'
+:saturation: '+1'
+:sharpness: '+1'
+:metering_mode: Evaluative
+:focus_range: Not Known
+:canon_exposure_mode: Program AE
+:lens_type: Unknown (-1)
+:max_focal_length: 85 mm
+:min_focal_length: 17 mm
+:focal_units: 1/mm
+:max_aperture: 5.6
+:min_aperture: 32
+:flash_activity: 0
+:flash_bits: (none)
+:focus_continuous: Single
+:zoom_source_width: 0
+:zoom_target_width: 0
+:photo_effect: 'Off'
+:manual_flash_output: n/a
+:focal_type: Zoom
+:focal_plane_x_size: 23.04 mm
+:focal_plane_y_size: 15.37 mm
+:auto_iso: 100
+:base_iso: 200
+:measured_ev: 13.25
+:target_aperture: 9
+:target_exposure_time: !ruby/object:Rational
+  denominator: 251
+  numerator: 1
+:exposure_compensation: 0
+:white_balance: Auto
+:slow_shutter: None
+:sequence_number: 0
+:optical_zoom_code: n/a
+:flash_guide_number: 0
+:flash_exposure_comp: 0
+:auto_exposure_bracketing: 'Off'
+:aeb_bracket_value: 0
+:control_mode: Camera Local Control
+:measured_ev2: 13.5
+:bulb_duration: 0
+:camera_type: EOS Mid-range
+:auto_rotate: None
+:nd_filter: n/a
+:self_timer2: 0
+:canon_image_type: Canon EOS 20D
+:canon_firmware_version: Firmware 1.0.2
+:owner_name: unknown
+:serial_number: 0330113864
+:set_function_when_shooting: Image replay
+:long_exposure_noise_reduction: 'Off'
+:flash_sync_speed_av: Auto
+:shutter-ae_lock: AF/AE lock
+:af_assist_beam: Emits
+:exposure_level_increments: 1/3 Stop
+:flash_firing: Fires
+:iso_expansion: 'On'
+:aeb_sequence_auto_cancel: 0,-,+/Enabled
+:superimposed_display: 'On'
+:menu_button_display_position: Previous (top if power off)
+:mirror_lockup: Disable
+:af_point_selection_method: Normal
+:ettlii: Evaluative
+:shutter_curtain_sync: 1st-curtain sync
+:safety_shift_in_av_or_tv: Disable
+:lens_af_stop_button: AF stop
+:add_original_decision_data: 'Off'
+:canon_model_id: EOS 20D
+:num_af_points: 9
+:valid_af_points: 9
+:canon_image_width: 3504
+:canon_image_height: 2336
+:af_image_width: 3504
+:af_image_height: 2336
+:af_area_width: 78
+:af_area_height: 78
+:af_area_x_positions: 8 -555 571 -931 8 947 -555 571 8
+:af_area_y_positions: 504 270 270 4 4 4 -262 -262 -496
+:af_points_in_focus: 4
+:thumbnail_image_valid_area: 0 159 7 112
+:serial_number_format: Format 2
+:original_decision_data_offset: 0
+:file_number: 793-9390
+:bracket_mode: 'Off'
+:bracket_value: 0
+:bracket_shot_number: 0
+:long_exposure_noise_reduction2: 'Off'
+:wb_bracket_mode: 'Off'
+:wb_bracket_value_ab: 0
+:wb_bracket_value_gm: 0
+:filter_effect: None
+:toning_effect: None
+:tone_curve: Standard
+:sharpness_frequency: n/a
+:sensor_red_level: 0
+:sensor_blue_level: 0
+:white_balance_red: 0
+:white_balance_blue: 0
+:color_temperature: 4800
+:picture_style: None
+:digital_gain: 0
+:wb_shift_ab: 0
+:wb_shift_gm: 0
+:measured_rggb: 674 1024 1024 670
+:vrd_offset: 0
+:sensor_width: 3596
+:sensor_height: 2360
+:sensor_left_border: 84
+:sensor_top_border: 19
+:sensor_right_border: 3587
+:sensor_bottom_border: 2354
+:black_mask_left_border: 0
+:black_mask_top_border: 0
+:black_mask_right_border: 0
+:black_mask_bottom_border: 0
+:wb_rggb_levels_as_shot: 1973 1015 1015 1663
+:color_temp_as_shot: 4662
+:wb_rggb_levels_auto: 1973 1023 1023 1663
+:color_temp_auto: 4662
+:wb_rggb_levels_daylight: 1995 1023 1023 1509
+:color_temp_daylight: 5200
+:wb_rggb_levels_shade: 2292 1023 1023 1267
+:color_temp_shade: 7000
+:wb_rggb_levels_cloudy: 2160 1023 1023 1373
+:color_temp_cloudy: 6000
+:wb_rggb_levels_tungsten: 1410 1023 1023 2408
+:color_temp_tungsten: 3196
+:wb_rggb_levels_fluorescent: 1797 1023 1023 2058
+:color_temp_fluorescent: 3952
+:wb_rggb_levels_flash: 2187 1023 1023 1333
+:color_temp_flash: 6309
+:wb_rggb_levels_custom1: 2095 1023 1023 1316
+:color_temp_custom1: 6163
+:wb_rggb_levels_custom2: 1912 1023 1023 1627
+:color_temp_custom2: 4792
+:color_tone: Normal
+:user_comment: ''
+:flashpix_version: '0100'
+:color_space: sRGB
+:exif_image_width: 3504
+:exif_image_height: 2336
+:interop_index: R98 - DCF basic file (sRGB)
+:interop_version: '0100'
+:focal_plane_x_resolution: 2886.363636
+:focal_plane_y_resolution: 2885.805763
+:focal_plane_resolution_unit: inches
+:custom_rendered: Normal
+:exposure_mode: Auto
+:scene_capture_type: Standard
+:compression: JPEG (old-style)
+:thumbnail_offset: 9728
+:thumbnail_length: 11259
+:image_width: 3504
+:image_height: 2336
+:encoding_process: Baseline DCT, Huffman coding
+:bits_per_sample: 8
+:color_components: 3
+:y_cb_cr_sub_sampling: YCbCr4:2:2 (2 1)
+:aperture: 9.0
+:drive_mode: Single-frame Shooting
+:image_size: 3504x2336
+:lens: 17.0 - 85.0 mm
+:lens_id: Unknown 17-85mm
+:scale_factor35efl: 1.0
+:shooting_mode: Program AE
+:shutter_speed: !ruby/object:Rational
+  denominator: 250
+  numerator: 1
+:thumbnail_image: (Binary data 11259 bytes)
+:wb_rggb_levels: 1973 1015 1015 1663
+:blue_balance: 1.638424
+:circle_of_confusion: 0.030 mm
+:fov: 23.7 deg
+:focal_length35efl: '85.0 mm (35 mm equivalent: 85.6 mm)'
+:hyperfocal_distance: 26.91 m
+:lens35efl: '17.0 - 85.0 mm (35 mm equivalent: 17.1 - 85.6 mm)'
+:light_value: 13.3
+:red_balance: 1.943842