bogado-exifr 0.10.8

data/CHANGELOG

@@ -0,0 +1,69 @@
+EXIF Reader 0.10.8
+* feature request; "[#23694] The object interface of JPEG is different from the TIFF one."
+
+EXIF Reader 0.10.7
+* bug fix; "[#22403] Wrong file size reported"
+
+EXIF Reader 0.10.6.1
+* moved to GitHub
+
+EXIF Reader 0.10.6
+* bug fix (thanks to Forian Munz for reporting it); endless loop when reading a malformed EXIF/TIFF
+
+EXIF Reader 0.10.5
+* bug fix; "[#15421] duplicate orientation field behavior", first field (of any type) is leading now
+* Ruby 1.9 compatible
+
+EXIF Reader 0.10.4
+* Thumbnail extraction; [#15317] Please add thumbnail extraction
+
+EXIF Reader 0.10.3
+* YAML friendly; can now safely (de)serialize
+
+EXIF Reader 0.10.2
+* bug fix (thanks to Alexander Staubo for providing me with sample data);
+  don't fail on out-of-range IFD offsets for Apple Aperture generated JPGs
+
+EXIF Reader 0.10.1
+* old style exif access
+
+EXIF Reader 0.10
+* TIFF support
+
+EXIF Reader 0.9.6
+* bug fix; "[#8458] Conversion from string to Time fails", weird dates will now reflect nil
+
+EXIF Reader 0.9.5.1
+* make tinderbox happy by hiding rcov task
+
+EXIF Reader 0.9.5
+* patch calls to jpeg through to exif, i.e. jpeg., i.e. jpeg.model == jpeg.exif.model
+* fix exifr commandline utility, needs require 'exifr' now
+* improve test helper
+* reduce size of test images
+* include tests for tinderbox
+
+EXIF Reader 0.9.4
+* bug fix (thanks to Benjamin Storrier for providing me with sample date);
+  multiple app1 frames will potentially overwrite EXIF tag
+
+EXIF Reader 0.9.3
+* bug fix; "[#4876] Unable to extract gpsinfo"
+* one-off bug in TiffHeader found and fixed
+* make "InteroperabilityIndex" available
+
+EXIF Reader 0.9.2
+* bug fix; "[#4595] EXIFR::JPEG doesn't support multiple comments", the
+  comment property of a JPEG object now contains an array instead of a string
+  when multiple COM frames are found
+* EXIF orientation modules including RMagick code to rotate to viewable state
+* access to thumbnail included in EXIF
+* simple commandline utility, "exifr", to view image properties
+* overall code improvements including documentation and tests
+
+EXIF Reader 0.9.1
+* bug fix; "4321 Can't create object", division by zero when
+  denominator of rational value is zero
+
+EXIF Reader 0.9
+* 1st release

data/README.rdoc

@@ -0,0 +1,24 @@
+= EXIF Reader
+EXIF Reader is a module to read metadata from JPEG and TIFF images.
+
+== Examples
+  EXIFR::JPEG.new('IMG_6841.JPG').width               # => 2272
+  EXIFR::JPEG.new('IMG_6841.JPG').height              # => 1704
+  EXIFR::JPEG.new('IMG_6841.JPG').exif?               # => true
+  EXIFR::JPEG.new('IMG_6841.JPG').model               # => "Canon PowerShot G3"
+  EXIFR::JPEG.new('IMG_6841.JPG').date_time           # => Fri Feb 09 16:48:54 +0100 2007
+  EXIFR::JPEG.new('IMG_6841.JPG').exposure_time.to_s  # => "1/15"
+  EXIFR::JPEG.new('IMG_6841.JPG').f_number.to_f       # => 2.0
+
+  EXIFR::TIFF.new('DSC_0218.TIF').width               # => 3008
+  EXIFR::TIFF.new('DSC_0218.TIF')[1].width            # => 160
+  EXIFR::TIFF.new('DSC_0218.TIF').model               # => "NIKON D1X"
+  EXIFR::TIFF.new('DSC_0218.TIF').date_time           # => Tue May 23 19:15:32 +0200 2006
+  EXIFR::TIFF.new('DSC_0218.TIF').exposure_time.to_s  # => "1/100"
+  EXIFR::TIFF.new('DSC_0218.TIF').f_number.to_f       # => 5.0
+
+== Author
+R.W. van 't Veer
+
+== Copyright
+Copyright (c) 2006, 2007, 2008, 2009 - R.W. van 't Veer

data/Rakefile

@@ -0,0 +1,39 @@
+# Copyright (c) 2006, 2007, 2008, 2009 - R.W. van 't Veer
+
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+task :default => :test
+
+desc 'Generate site'
+task :site => :rdoc do
+  system 'rsync -av --delete doc/ remvee@rubyforge.org:/var/www/gforge-projects/exifr'
+end
+
+Rake::RDocTask.new do |rd|
+  rd.title = 'EXIF Reader for Ruby API Documentation'
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = "doc/api"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+end
+
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'tests'
+  t.test_files = FileList['tests/*_test.rb']
+end
+
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do |t|
+    t.libs << 'lib' << 'tests'
+    t.test_files = FileList['tests/*_test.rb']
+  end
+
+  desc 'Remove all artifacts left by testing and packaging'
+  task :clean => [:clobber_rdoc, :clobber_rcov]
+rescue LoadError
+  desc 'Remove all artifacts left by testing and packaging'
+  task :clean => [:clobber_rdoc]
+end

data/bin/exifr

@@ -0,0 +1,49 @@
+require 'exifr'
+include EXIFR
+
+def pp_jpeg(fname)
+  jpeg = JPEG.new(fname)
+  ks = %w(width height comment bits)
+  ks += jpeg.exif.to_hash.keys.map{|a|a.to_s}.sort{|a,b|a<=>b} if jpeg.exif?
+
+  l = []
+  ks[0..3].each do |k|
+    v = jpeg.send(k)
+    l << [k, v.inspect] if v
+  end
+  ks[4..-1].each do |k|
+    v = jpeg.exif.to_hash[k.to_sym]
+    l << [k, v.inspect] if v
+  end
+  pp(fname, l)
+end
+
+def pp_tiff(fname)
+  tiff = TIFF.new(fname)
+  tiff.each_with_index do |img,index|
+    l = []
+    l << ['width', img.width] << ['height', img.height]
+    img.to_hash.keys.map{|a|a.to_s}.sort{|a,b|a<=>b}.each do |key|
+      l << [key, img.to_hash[key.to_sym].inspect]
+    end
+    pp(tiff.size == 1 ? fname : "#{fname}[#{index}]", l)
+  end
+end
+
+def pp(fname, l)
+  puts "#{fname}:"
+  f = "  %#{l.sort{|a,b|a[0].size <=> b[0].size}.last[0].size}s = %s\n"
+  l.each{|k,v|puts f  % [k, [v].flatten.map{|t|t.to_s}.join(', ')]}
+end
+
+if ARGV.size == 0
+  STDERR.puts "Usage: #{$0} FILE .."
+else
+  ARGV.each do |fname|
+    case fname
+    when /\.(jpg|jpeg)$/i; pp_jpeg fname
+    when /\.(tif|tiff)$/i; pp_tiff fname
+    end
+    puts
+  end
+end

data/lib/exifr.rb

@@ -0,0 +1,4 @@
+# Copyright (c) 2006, 2007, 2008, 2009 - R.W. van 't Veer
+
+require 'jpeg'
+require 'tiff'

data/lib/jpeg.rb

@@ -0,0 +1,109 @@
+# Copyright (c) 2006, 2007, 2008, 2009 - R.W. van 't Veer
+
+require 'stringio'
+
+module EXIFR
+  # = JPEG decoder
+  #
+  # == Examples
+  #   EXIFR::JPEG.new('IMG_3422.JPG').width         # -> 2272
+  #   EXIFR::JPEG.new('IMG_3422.JPG').exif.model    # -> "Canon PowerShot G3"
+  class JPEG
+    # image height
+    attr_reader :height
+    # image width
+    attr_reader :width
+    # number of bits per ??
+    attr_reader :bits # :nodoc:
+    # comment; a string if one comment found, an array if more,
+    # otherwise <tt>nil</tt>
+    attr_reader :comment
+    # EXIF data if available
+    attr_reader :exif
+
+    # +file+ is a filename or an IO object.
+    def initialize(file)
+      if file.kind_of? String
+        File.open(file, 'rb') { |io| examine(io) }
+      else
+        examine(file.dup)
+      end
+    end
+
+    # Returns +true+ when EXIF data is available.
+    def exif?
+      !exif.nil?
+    end
+
+    # Return thumbnail data when available.
+    def thumbnail
+      @exif && @exif.jpeg_thumbnails && @exif.jpeg_thumbnails.first
+    end
+
+    # Get a hash presentation of the image.
+    def to_hash
+      h = {:width => width, :height => height, :bits => bits, :comment => comment}
+      h.merge!(exif) if exif?
+      h
+    end
+
+    # Dispatch to EXIF.  When no EXIF data is available but the
+    # +method+ does exist for EXIF data +nil+ will be returned.
+    def method_missing(method, *args)
+      super unless args.empty?
+      super unless TIFF::TAGS.include?(method.to_s)
+      @exif.send method if @exif
+    end
+
+    def respond_to?(method) # :nodoc:
+      super || TIFF::TAGS.include?(method.to_s)
+    end
+
+    def methods # :nodoc:
+      super + TIFF::TAGS
+    end
+
+    class << self
+      alias instance_methods_without_jpeg_extras instance_methods
+      def instance_methods(include_super = true) # :nodoc:
+        instance_methods_without_jpeg_extras(include_super) + TIFF::TAGS
+      end
+    end
+
+  private
+    def examine(io)
+      class << io
+        def readbyte; readchar; end unless method_defined?(:readbyte)
+        def readint; (readbyte << 8) + readbyte; end
+        def readframe; read(readint - 2); end
+        def readsof; [readint, readbyte, readint, readint, readbyte]; end
+        def next
+          c = readbyte while c != 0xFF
+          c = readbyte while c == 0xFF
+          c
+        end
+      end unless io.respond_to? :readsof
+
+      raise 'malformed JPEG' unless io.readbyte == 0xFF && io.readbyte == 0xD8 # SOI
+
+      app1s = []
+      while marker = io.next
+        case marker
+          when 0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF # SOF markers
+            length, @bits, @height, @width, components = io.readsof
+            raise 'malformed JPEG' unless length == 8 + components * 3
+          when 0xD9, 0xDA;  break # EOI, SOS
+          when 0xFE;        (@comment ||= []) << io.readframe # COM
+          when 0xE1;        app1s << io.readframe # APP1, may contain EXIF tag
+          else              io.readframe # ignore frame
+        end
+      end
+
+      @comment = @comment.first if @comment && @comment.size == 1
+
+      if app1 = app1s.find { |d| d[0..5] == "Exif\0\0" }
+        @exif = TIFF.new(StringIO.new(app1[6..-1]))
+      end
+    end
+  end
+end

data/lib/tiff.rb

@@ -0,0 +1,553 @@
+# Copyright (c) 2007, 2008, 2009 - R.W. van 't Veer
+
+require 'rational'
+
+module EXIFR
+  # = TIFF decoder
+  #
+  # == Date properties
+  # The properties <tt>:date_time</tt>, <tt>:date_time_original</tt>,
+  # <tt>:date_time_digitized</tt> coerced into Time objects.
+  #
+  # == Orientation
+  # The property <tt>:orientation</tt> describes the subject rotated and/or
+  # mirrored in relation to the camera.  It is translated to one of the following
+  # instances:
+  # * TopLeftOrientation
+  # * TopRightOrientation
+  # * BottomRightOrientation
+  # * BottomLeftOrientation
+  # * LeftTopOrientation
+  # * RightTopOrientation
+  # * RightBottomOrientation
+  # * LeftBottomOrientation
+  #
+  # These instances of Orientation have two methods:
+  # * <tt>to_i</tt>; return the original integer
+  # * <tt>transform_rmagick(image)</tt>; transforms the given RMagick::Image
+  #   to a viewable version
+  #
+  # == Examples
+  #   EXIFR::TIFF.new('DSC_0218.TIF').width           # => 3008
+  #   EXIFR::TIFF.new('DSC_0218.TIF')[1].width        # => 160
+  #   EXIFR::TIFF.new('DSC_0218.TIF').model           # => "NIKON D1X"
+  #   EXIFR::TIFF.new('DSC_0218.TIF').date_time       # => Tue May 23 19:15:32 +0200 2006
+  #   EXIFR::TIFF.new('DSC_0218.TIF').exposure_time   # => Rational(1, 100)
+  #   EXIFR::TIFF.new('DSC_0218.TIF').orientation     # => EXIFR::TIFF::Orientation
+  class TIFF
+    include Enumerable
+
+    # JPEG thumbnails
+    attr_reader :jpeg_thumbnails
+
+    TAG_MAPPING = {} # :nodoc:
+    TAG_MAPPING.merge!({
+      :image => {
+        0x00FE => :new_subfile_type,
+        0x00FF => :subfile_type,
+        0x0100 => :image_width,
+        0x0101 => :image_length,
+        0x0102 => :bits_per_sample,
+        0x0103 => :compression,
+        0x0106 => :photometric_interpretation,
+        0x0107 => :threshholding,
+        0x0108 => :cell_width,
+        0x0109 => :cell_length,
+        0x010a => :fill_order,
+        0x010d => :document_name,
+        0x010e => :image_description,
+        0x010f => :make,
+        0x0110 => :model,
+        0x0111 => :strip_offsets,
+        0x0112 => :orientation,
+        0x0115 => :samples_per_pixel,
+        0x0116 => :rows_per_strip,
+        0x0117 => :strip_byte_counts,
+        0x0118 => :min_sample_value,
+        0x0119 => :max_sample_value,
+        0x011a => :x_resolution,
+        0x011b => :y_resolution,
+        0x011c => :planar_configuration,
+        0x011d => :page_name,
+        0x011e => :x_position,
+        0x011f => :y_position,
+        0x0120 => :free_offsets,
+        0x0121 => :free_byte_counts,
+        0x0122 => :gray_response_unit,
+        0x0123 => :gray_response_curve,
+        0x0124 => :t4_options,
+        0x0125 => :t6_options,
+        0x0128 => :resolution_unit,
+        0x012d => :transfer_function,
+        0x0131 => :software,
+        0x0132 => :date_time,
+        0x013b => :artist,
+        0x013c => :host_computer,
+        0x013a => :predictor,
+        0x013e => :white_point,
+        0x013f => :primary_chromaticities,
+        0x0140 => :color_map,
+        0x0141 => :halftone_hints,
+        0x0142 => :tile_width,
+        0x0143 => :tile_length,
+        0x0144 => :tile_offsets,
+        0x0145 => :tile_byte_counts,
+        0x0146 => :bad_fax_lines,
+        0x0147 => :clean_fax_data,
+        0x0148 => :consecutive_bad_fax_lines,
+        0x014a => :sub_ifds,
+        0x014c => :ink_set,
+        0x014d => :ink_names,
+        0x014e => :number_of_inks,
+        0x0150 => :dot_range,
+        0x0151 => :target_printer,
+        0x0152 => :extra_samples,
+        0x0156 => :transfer_range,
+        0x0157 => :clip_path,
+        0x0158 => :x_clip_path_units,
+        0x0159 => :y_clip_path_units,
+        0x015a => :indexed,
+        0x015b => :jpeg_tables,
+        0x015f => :opi_proxy,
+        0x0190 => :global_parameters_ifd,
+        0x0191 => :profile_type,
+        0x0192 => :fax_profile,
+        0x0193 => :coding_methods,
+        0x0194 => :version_year,
+        0x0195 => :mode_number,
+        0x01B1 => :decode,
+        0x01B2 => :default_image_color,
+        0x0200 => :jpegproc,
+        0x0201 => :jpeg_interchange_format,
+        0x0202 => :jpeg_interchange_format_length,
+        0x0203 => :jpeg_restart_interval,
+        0x0205 => :jpeg_lossless_predictors,
+        0x0206 => :jpeg_point_transforms,
+        0x0207 => :jpeg_q_tables,
+        0x0208 => :jpeg_dc_tables,
+        0x0209 => :jpeg_ac_tables,
+        0x0211 => :ycb_cr_coefficients,
+        0x0212 => :ycb_cr_sub_sampling,
+        0x0213 => :ycb_cr_positioning,
+        0x0214 => :reference_black_white,
+        0x022F => :strip_row_counts,
+        0x02BC => :xmp,
+        0x800D => :image_id,
+        0x87AC => :image_layer,
+        0x8298 => :copyright,
+        0x83bb => :iptc,
+
+        0x8769 => :exif,
+        0x8825 => :gps,
+      },
+
+      :exif => {
+        0x829a => :exposure_time,
+        0x829d => :f_number,
+        0x8822 => :exposure_program,
+        0x8824 => :spectral_sensitivity,
+        0x8827 => :iso_speed_ratings,
+        0x8828 => :oecf,
+        0x9000 => :exif_version,
+        0x9003 => :date_time_original,
+        0x9004 => :date_time_digitized,
+        0x9101 => :components_configuration,
+        0x9102 => :compressed_bits_per_pixel,
+        0x9201 => :shutter_speed_value,
+        0x9202 => :aperture_value,
+        0x9203 => :brightness_value,
+        0x9204 => :exposure_bias_value,
+        0x9205 => :max_aperture_value,
+        0x9206 => :subject_distance,
+        0x9207 => :metering_mode,
+        0x9208 => :light_source,
+        0x9209 => :flash,
+        0x920a => :focal_length,
+        0x9214 => :subject_area,
+        0x927c => :maker_note,
+        0x9286 => :user_comment,
+        0x9290 => :subsec_time,
+        0x9291 => :subsec_time_orginal,
+        0x9292 => :subsec_time_digitized,
+        0xa000 => :flashpix_version,
+        0xa001 => :color_space,
+        0xa002 => :pixel_x_dimension,
+        0xa003 => :pixel_y_dimension,
+        0xa004 => :related_sound_file,
+        0xa20b => :flash_energy,
+        0xa20c => :spatial_frequency_response,
+        0xa20e => :focal_plane_x_resolution,
+        0xa20f => :focal_plane_y_resolution,
+        0xa210 => :focal_plane_resolution_unit,
+        0xa214 => :subject_location,
+        0xa215 => :exposure_index,
+        0xa217 => :sensing_method,
+        0xa300 => :file_source,
+        0xa301 => :scene_type,
+        0xa302 => :cfa_pattern,
+        0xa401 => :custom_rendered,
+        0xa402 => :exposure_mode,
+        0xa403 => :white_balance,
+        0xa404 => :digital_zoom_ratio,
+        0xa405 => :focal_length_in_35mm_film,
+        0xa406 => :scene_capture_type,
+        0xa407 => :gain_control,
+        0xa408 => :contrast,
+        0xa409 => :saturation,
+        0xa40a => :sharpness,
+        0xa40b => :device_setting_description,
+        0xa40c => :subject_distance_range,
+        0xa420 => :image_unique_id
+      },
+
+      :gps => {
+        0x0000 => :gps_version_id,
+        0x0001 => :gps_latitude_ref,
+        0x0002 => :gps_latitude,
+        0x0003 => :gps_longitude_ref,
+        0x0004 => :gps_longitude,
+        0x0005 => :gps_altitude_ref,
+        0x0006 => :gps_altitude  ,
+        0x0007 => :gps_time_stamp,
+        0x0008 => :gps_satellites,
+        0x0009 => :gps_status,
+        0x000a => :gps_measure_mode,
+        0x000b => :gps_dop,
+        0x000c => :gps_speed_ref,
+        0x000d => :gps_speed,
+        0x000e => :gps_track_ref,
+        0x000f => :gps_track,
+        0x0010 => :gps_img_direction_ref,
+        0x0011 => :gps_img_direction,
+        0x0012 => :gps_map_datum,
+        0x0013 => :gps_dest_latitude_ref,
+        0x0014 => :gps_dest_latitude,
+        0x0015 => :gps_dest_longitude_ref,
+        0x0016 => :gps_dest_longitude,
+        0x0017 => :gps_dest_bearing_ref,
+        0x0018 => :gps_dest_bearing,
+        0x0019 => :gps_dest_distance_ref,
+        0x001a => :gps_dest_distance,
+        0x001b => :gps_processing_method,
+        0x001c => :gps_area_information,
+        0x001d => :gps_date_stamp,
+        0x001e => :gps_differential,
+      },
+    })
+    IFD_TAGS = [:image, :exif, :gps] # :nodoc:
+
+    time_proc = proc do |value|
+      if value =~ /^(\d{4}):(\d\d):(\d\d) (\d\d):(\d\d):(\d\d)$/
+        Time.mktime($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i) rescue nil
+      else
+        value
+      end
+    end
+
+    # The orientation of the image with respect to the rows and columns.
+    class Orientation
+      def initialize(value, type) # :nodoc:
+        @value, @type = value, type
+      end
+
+      # Field value.
+      def to_i
+        @value
+      end
+
+      # Rotate and/or flip for proper viewing.
+      def transform_rmagick(img)
+        case @type
+        when :TopRight    ; img.flop
+        when :BottomRight ; img.rotate(180)
+        when :BottomLeft  ; img.flip
+        when :LeftTop     ; img.rotate(90).flop
+        when :RightTop    ; img.rotate(90)
+        when :RightBottom ; img.rotate(270).flop
+        when :LeftBottom  ; img.rotate(270)
+        else
+          img
+        end
+      end
+
+      def ==(other) # :nodoc:
+        Orientation === other && to_i == other.to_i
+      end
+    end
+
+    ORIENTATIONS = [] # :nodoc:
+    [
+      nil,
+      :TopLeft,
+      :TopRight,
+      :BottomRight,
+      :BottomLeft,
+      :LeftTop,
+      :RightTop,
+      :RightBottom,
+      :LeftBottom,
+    ].each_with_index do |type,index|
+      next unless type
+      const_set("#{type}Orientation", ORIENTATIONS[index] = Orientation.new(index, type))
+    end
+
+    ADAPTERS = Hash.new { proc { |v| v } } # :nodoc:
+    ADAPTERS.merge!({
+      :date_time_original => time_proc,
+      :date_time_digitized => time_proc,
+      :date_time => time_proc,
+      :orientation => proc { |v| ORIENTATIONS[v] }
+    })
+
+    # Names for all recognized TIFF fields.
+    TAGS = ([TAG_MAPPING.keys, TAG_MAPPING.values.map{|v|v.values}].flatten.uniq - IFD_TAGS).map{|v|v.to_s}
+
+    # +file+ is a filename or an IO object.
+    def initialize(file)
+      data = Data.new(file)
+
+      case data[0..1]
+      when 'II'; data.endianess = 'v'
+      when 'MM'; data.endianess = 'n'
+      else; raise 'no II or MM marker found'
+      end
+
+      @ifds = [IFD.new(data)]
+      while ifd = @ifds.last.next
+        break if @ifds.find{|i| i.offset == ifd.offset}
+        @ifds << ifd
+      end
+
+      @jpeg_thumbnails = @ifds.map do |ifd|
+        if ifd.jpeg_interchange_format && ifd.jpeg_interchange_format_length
+          start, length = ifd.jpeg_interchange_format, ifd.jpeg_interchange_format_length
+          data[start..(start + length)]
+        end
+      end.compact
+    end
+
+    # Number of images.
+    def size
+      @ifds.size
+    end
+
+    # Yield for each image.
+    def each
+      @ifds.each { |ifd| yield ifd }
+    end
+
+    # Get +index+ image.
+    def [](index)
+      index.is_a?(Symbol) ? to_hash[index] : @ifds[index]
+    end
+
+    # Dispatch to first image.
+    def method_missing(method, *args)
+      super unless args.empty?
+
+      if @ifds.first.respond_to?(method)
+        @ifds.first.send(method)
+      elsif TAGS.include?(method.to_s)
+        @ifds.first.to_hash[method]
+      else
+        super
+      end
+    end
+
+    def respond_to?(method) # :nodoc:
+      super ||
+        (@ifds && @ifds.first && @ifds.first.respond_to?(method)) ||
+        TAGS.include?(method.to_s)
+    end
+
+    def methods # :nodoc:
+      (super + TAGS + IFD.instance_methods(false)).uniq
+    end
+
+    class << self
+      alias instance_methods_without_tiff_extras instance_methods
+      def instance_methods(include_super = true) # :nodoc:
+        (instance_methods_without_tiff_extras(include_super) + TAGS + IFD.instance_methods(false)).uniq
+      end
+    end
+
+    # Convenience method to access image width.
+    def width; @ifds.first.width; end
+
+    # Convenience method to access image height.
+    def height; @ifds.first.height; end
+
+    # Get a hash presentation of the (first) image.
+    def to_hash; @ifds.first.to_hash; end
+
+    def inspect # :nodoc:
+      @ifds.inspect
+    end
+
+    class IFD # :nodoc:
+      attr_reader :type, :fields, :offset
+
+      def initialize(data, offset = nil, type = :image)
+        @data, @offset, @type, @fields = data, offset, type, {}
+
+        pos = offset || @data.readlong(4)
+        num = @data.readshort(pos)
+        pos += 2
+
+        num.times do
+          add_field(Field.new(@data, pos))
+          pos += 12
+        end
+
+        @offset_next = @data.readlong(pos)
+      end
+
+      def method_missing(method, *args)
+        super unless args.empty? && TAGS.include?(method.to_s)
+        to_hash[method]
+      end
+
+      def width; image_width; end
+      def height; image_length; end
+
+      def to_hash
+        @hash ||= begin
+          result = @fields.dup
+          result.delete_if { |key,value| value.nil? }
+          result.each do |key,value|
+            if IFD_TAGS.include? key
+              result.merge!(value.to_hash)
+              result.delete key
+            end
+          end
+        end
+      end
+
+      def inspect
+        to_hash.inspect
+      end
+
+      def next?
+        @offset_next != 0 && @offset_next < @data.size
+      end
+
+      def next
+        IFD.new(@data, @offset_next) if next?
+      end
+
+      def to_yaml_properties
+        ['@fields']
+      end
+
+    private
+      def add_field(field)
+        return unless tag = TAG_MAPPING[@type][field.tag]
+        return if @fields[tag]
+
+        if IFD_TAGS.include? tag
+          @fields[tag] = IFD.new(@data, field.offset, tag)
+        else
+          value = field.value.map { |v| ADAPTERS[tag][v] } if field.value
+          @fields[tag] = value.kind_of?(Array) && value.size == 1 ? value.first : value
+        end
+      end
+    end
+
+    class Field # :nodoc:
+      attr_reader :tag, :offset, :value
+
+      def initialize(data, pos)
+        @tag, count, @offset = data.readshort(pos), data.readlong(pos + 4), data.readlong(pos + 8)
+
+        case data.readshort(pos + 2)
+        when 1, 6 # byte, signed byte
+          # TODO handle signed bytes
+          len, pack = count, proc { |d| d }
+        when 2 # ascii
+          len, pack = count, proc { |d| d.strip }
+        when 3, 8 # short, signed short
+          # TODO handle signed
+          len, pack = count * 2, proc { |d| d.unpack(data.short + '*') }
+        when 4, 9 # long, signed long
+          # TODO handle signed
+          len, pack = count * 4, proc { |d| d.unpack(data.long + '*') }
+        when 5, 10
+          len, pack = count * 8, proc do |d|
+            r = []
+            d.unpack(data.long + '*').each_with_index do |v,i|
+              i % 2 == 0 ? r << [v] : r.last << v
+            end
+            r.map do |f|
+              if f[1] == 0 # allow NaN and Infinity
+                f[0].to_f.quo(f[1])
+              else
+                Rational.respond_to?(:reduce) ? Rational.reduce(*f) : f[0].quo(f[1])
+              end
+            end
+          end
+        end
+
+        if len && pack
+          start = len > 4 ? @offset : (pos + 8)
+          @value = [pack[data[start..(start + len - 1)]]].flatten
+        end
+      end
+    end
+
+    class Data
+      attr_reader :short, :long
+
+      def initialize(file)
+        @file = file.respond_to?(:read) ? file : File.open(file, "rb")
+        @buff = []
+        @pos = 0
+        @size = 0
+      end
+
+      def endianess=(endianess)
+        @short = endianess.downcase
+        @long = endianess.upcase
+      end
+
+      def [](pos)
+        # handle Ranges
+        if (pos.respond_to?(:min) and pos.respond_to?(:max))
+          min = pos.min
+          max = pos.max
+        else
+          min = pos
+          max = pos
+        end
+
+        if (min < @pos or max >= @pos + @size)
+          buff_read(min, max - min)
+        end
+
+        return @buffer[(min - @pos)..(max - @pos)]
+      end
+
+      def readshort(pos)
+        self[pos..(pos + 1)].unpack(@short)[0]
+      end
+
+      def readlong(pos)
+        self[pos..(pos + 3)].unpack(@long)[0]
+      end
+
+      def size
+        @file.seek(0, IO::SEEK_END)
+        return @file.pos
+      end
+
+      private
+      def buff_read(pos, size)
+        @pos = pos
+        @size = size < 4096? 4096 : size;
+        @file.seek(pos)
+        @buffer = @file.read(@size)
+        # read can read less then the requested size
+        @size = @buffer.size
+      end
+    end
+  end
+end

data/tests/jpeg_test.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+#
+# Copyright (c) 2006, 2007, 2008, 2009 - R.W. van 't Veer
+
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class JPEGTest < Test::Unit::TestCase
+  def test_initialize
+    all_test_jpegs.each do |fname|
+      assert_nothing_raised do
+        JPEG.new(fname)
+      end
+      assert_nothing_raised do
+        open(fname) { |rd| JPEG.new(rd) }
+      end
+      assert_nothing_raised do
+        JPEG.new(StringIO.new(File.read(fname)))
+      end
+    end
+  end
+
+  def test_size
+    j = JPEG.new(f('image.jpg'))
+    assert_equal j.width, 100
+    assert_equal j.height, 75
+
+    j = JPEG.new(f('exif.jpg'))
+    assert_equal j.width, 100
+    assert_equal j.height, 75
+
+    j = JPEG.new(f('1x1.jpg'))
+    assert_equal j.width, 1
+    assert_equal j.height, 1
+  end
+
+  def test_comment
+    assert_equal JPEG.new(f('image.jpg')).comment, "Here's a comment!"
+  end
+
+  def test_exif
+    assert ! JPEG.new(f('image.jpg')).exif?
+    assert JPEG.new(f('exif.jpg')).exif?
+    assert_not_nil JPEG.new(f('exif.jpg')).exif.date_time
+    assert_not_nil JPEG.new(f('exif.jpg')).exif.f_number
+  end
+
+  def test_to_hash
+    h = JPEG.new(f('image.jpg')).to_hash
+    assert_equal 100, h[:width]
+    assert_equal 75, h[:height]
+    assert_equal "Here's a comment!", h[:comment]
+
+    h = JPEG.new(f('exif.jpg')).to_hash
+    assert_equal 100, h[:width]
+    assert_equal 75, h[:height]
+    assert_kind_of Time, h[:date_time]
+  end
+
+  def test_exif_dispatch
+    j = JPEG.new(f('exif.jpg'))
+
+    assert JPEG.instance_methods.include?('date_time')
+    assert j.methods.include?('date_time')
+    assert j.respond_to?(:date_time)
+    assert j.respond_to?('date_time')
+    assert_not_nil j.date_time
+    assert_kind_of Time, j.date_time
+
+    assert_not_nil j.f_number
+    assert_kind_of Rational, j.f_number
+  end
+
+  def test_no_method_error
+    assert_nothing_raised { JPEG.new(f('image.jpg')).f_number }
+    assert_raise(NoMethodError) { JPEG.new(f('image.jpg')).foo }
+  end
+
+  def test_multiple_app1
+    assert JPEG.new(f('multiple-app1.jpg')).exif?
+  end
+
+  def test_thumbnail
+    count = 0
+    all_test_jpegs.each do |fname|
+      jpeg = JPEG.new(fname)
+      unless jpeg.thumbnail.nil?
+        assert_nothing_raised 'thumbnail not a JPEG' do
+          JPEG.new(StringIO.new(jpeg.thumbnail))
+        end
+        count += 1
+      end
+    end
+
+    assert count > 0, 'no thumbnails found'
+  end
+end

data/tests/test_helper.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+#
+# Copyright (c) 2006, 2007, 2008, 2009 - R.W. van 't Veer
+
+require 'test/unit'
+require 'stringio'
+require 'pp'
+
+$:.unshift("#{File.dirname(__FILE__)}/../lib")
+require 'exifr'
+include EXIFR
+
+
+def all_test_jpegs
+  Dir[f('*.jpg')]
+end
+
+
+def all_test_exifs
+  Dir[f('*.exif')]
+end
+
+def all_test_tiffs
+  Dir[f('*.tif')] + all_test_exifs
+end
+
+def f(fname)
+  "#{File.dirname(__FILE__)}/data/#{fname}"
+end
+
+def assert_literally_equal(expected, actual, *args)
+  assert_equal expected.to_s, actual.to_s, *args
+end
+
+class Hash
+  def to_s
+    keys.map{|k| k.to_s}.sort.map{|k| "#{k.inspect} => #{self[k].inspect}" }.join(', ')
+  end
+end

data/tests/tiff_test.rb

@@ -0,0 +1,165 @@
+#!/usr/bin/env ruby
+#
+# Copyright (c) 2006, 2007, 2008, 2009 - R.W. van 't Veer
+
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class TIFFTest < Test::Unit::TestCase
+  def setup
+    @t = TIFF.new(f('nikon_d1x.tif'))
+  end
+
+  def test_initialize
+    all_test_tiffs.each do |fname|
+      assert_nothing_raised do
+        TIFF.new(fname)
+      end
+      assert_nothing_raised do
+        open(fname) { |rd| TIFF.new(rd) }
+      end
+      assert_nothing_raised do
+        TIFF.new(StringIO.new(File.read(fname)))
+      end
+    end
+  end
+
+  def test_multiple_images
+    assert_equal 2, @t.size
+  end
+
+  def test_size
+    assert_equal 269, @t.image_width
+    assert_equal 269, @t.image_length
+    assert_equal 269, @t.width
+    assert_equal 269, @t.height
+    assert_equal 120, @t[1].image_width
+    assert_equal 160, @t[1].image_length
+    assert_equal 120, @t[1].width
+    assert_equal 160, @t[1].height
+
+    @t = TIFF.new(f('plain.tif'))
+    assert_equal 23, @t.image_width
+    assert_equal 24, @t.image_length
+    assert_equal 23, @t.width
+    assert_equal 24, @t.height
+  end
+
+  def test_enumerable
+    assert_equal @t[1], @t.find { |i| i.f_number.nil? }
+  end
+
+  def test_misc_fields
+    assert_equal 'Canon PowerShot G3', TIFF.new(f('canon-g3.exif')).model
+  end
+
+  def test_dates
+    (all_test_tiffs - [f('weird_date.exif'), f('plain.tif'), f('endless-loop.exif')]).each do |fname|
+      assert_kind_of Time, TIFF.new(fname).date_time
+    end
+    assert_nil TIFF.new(f('weird_date.exif')).date_time
+  end
+
+  def test_orientation
+    tested = 0 # count tests because not all exif samples have an orientation field
+    all_test_exifs.each do |fname|
+      orientation = TIFF.new(fname).orientation
+      if orientation
+        assert [
+          TIFF::TopLeftOrientation,
+          TIFF::TopRightOrientation,
+          TIFF::BottomRightOrientation,
+          TIFF::BottomLeftOrientation,
+          TIFF::LeftTopOrientation,
+          TIFF::RightTopOrientation,
+          TIFF::RightBottomOrientation,
+          TIFF::LeftBottomOrientation
+        ].any? { |c| orientation == c }, 'not an orientation'
+        assert orientation.respond_to?(:to_i)
+        assert orientation.respond_to?(:transform_rmagick)
+        tested += 1
+      end
+    end
+    assert tested > 0
+  end
+
+  def test_gps
+    t = TIFF.new(f('gps.exif'))
+    assert_equal "\2\2\0\0", t.gps_version_id
+    assert_equal 'N', t.gps_latitude_ref
+    assert_equal 'W', t.gps_longitude_ref
+    assert_equal [5355537.quo(100000), 0.quo(1), 0.quo(1)], t.gps_latitude
+    assert_equal [678886.quo(100000), 0.quo(1), 0.quo(1)], t.gps_longitude
+    assert_equal 'WGS84', t.gps_map_datum
+
+    (all_test_exifs - [f('gps.exif')]).each do |fname|
+      assert_nil TIFF.new(fname).gps_version_id
+    end
+  end
+
+  def test_ifd_dispatch
+    assert @t.respond_to?(:f_number)
+    assert @t.respond_to?('f_number')
+    assert @t.methods.include?('f_number')
+    assert TIFF.instance_methods.include?('f_number')
+
+    assert_not_nil @t.f_number
+    assert_kind_of Rational, @t.f_number
+    assert_not_nil @t[0].f_number
+    assert_kind_of Rational, @t[0].f_number
+  end
+
+  def test_avoid_dispatch_to_nonexistent_ifds
+    assert_nothing_raised do
+      all_test_tiffs.each do |fname|
+        t = TIFF.new(fname)
+        TIFF::TAGS.each { |tag| t.send(tag) }
+      end
+    end
+  end
+
+  def test_to_hash
+    all_test_tiffs.each do |fname|
+      t = TIFF.new(fname)
+      TIFF::TAGS.each do |key|
+        assert_literally_equal t.send(key), t.to_hash[key.to_sym], "#{key} not equal"
+      end
+    end
+  end
+
+  def test_old_style
+    assert_nothing_raised do
+      assert_not_nil @t[:f_number]
+    end
+  end
+
+  def test_yaml_dump_and_load
+    require 'yaml'
+
+    all_test_tiffs.each do |fname|
+      t = TIFF.new(fname)
+      y = YAML.dump(t)
+      assert_literally_equal t.to_hash, YAML.load(y).to_hash
+    end
+  end
+
+  def test_jpeg_thumbnails
+    count = 0
+    all_test_tiffs.each do |fname|
+      t = TIFF.new(fname)
+      unless t.jpeg_thumbnails.empty?
+        assert_nothing_raised do
+          t.jpeg_thumbnails.each do |n|
+            JPEG.new(StringIO.new(n))
+          end
+        end
+        count += 1
+      end
+    end
+    assert count > 0, 'no thumbnails found'
+  end
+
+  def test_should_not_loop_endlessly
+    TIFF.new(f('endless-loop.exif'))
+    assert true
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: bogado-exifr
+version: !ruby/object:Gem::Version 
+  version: 0.10.8
+platform: ruby
+authors: 
+- R.W. van 't Veer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-13 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: remco@remvee.net
+executables: 
+- exifr
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- CHANGELOG
+files: 
+- Rakefile
+- bin/exifr
+- lib/exifr.rb
+- lib/jpeg.rb
+- lib/tiff.rb
+- tests/data/1x1.jpg
+- tests/data/apple-aperture-1.5.exif
+- tests/data/canon-g3.exif
+- tests/data/Canon_PowerShot_A85.exif
+- tests/data/Casio-EX-S20.exif
+- tests/data/endless-loop.exif
+- tests/data/exif.jpg
+- tests/data/FUJIFILM-FinePix_S3000.exif
+- tests/data/gps.exif
+- tests/data/image.jpg
+- tests/data/multiple-app1.jpg
+- tests/data/nikon_d1x.tif
+- tests/data/Panasonic-DMC-LC33.exif
+- tests/data/plain.tif
+- tests/data/Trust-DC3500_MINI.exif
+- tests/data/weird_date.exif
+- tests/test_helper.rb
+- tests/jpeg_test.rb
+- tests/tiff_test.rb
+- README.rdoc
+- CHANGELOG
+has_rdoc: true
+homepage: http://github.com/remvee/exifr/
+post_install_message: 
+rdoc_options: 
+- --title
+- EXIF Reader for Ruby API Documentation
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: EXIF Reader is a module to read EXIF from JPEG images.
+test_files: []
+