ruby-exiv2 0.6 → 0.7

data/README

@@ -3,10 +3,14 @@ Library for handling exif image tags.
 Basic usage:
 
 > gem install ruby-exiv2
+> irb -r rubygems
+irb(main):001:0> require 'exiv2'
+=> true
+irb(main):002:0> @img = Exiv2::Image.new("a.jpg")
+=> #<Exiv2::Image:0x4c524c>
+irb(main):003:0> @exif = @img.exif
+=> #<Exiv2::Exif:0x4bc160>
+irb(main):004:0> @img.exif["Exif.Photo.PixelXDimension"]
+=> 1024
 
 
-require 'exiv2'
-@img = Exiv2::Image.new("a.jpg")
-@exif = @img.exif
-puts @img.exif["Exif.Photo.PixelXDimension"]
-=> 3024

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/packagetask'
 require 'rake/contrib/rubyforgepublisher'
 
 PKG_NAME = "ruby-exiv2"
-PKG_VERSION = "0.6"
+PKG_VERSION = "0.7"
 PKG_AUTHOR = "Max Lapshin"
 PKG_EMAIL = "max@maxidoors.ru"
 PKG_HOMEPAGE = "http://maxidoors.ru/"

data/ext/exif.cpp

@@ -1,5 +1,71 @@
 #include "exiv2.hpp"
 
+/*
+ * First, I have to get out type by key. If such key is forbidden, I will refuse to marshall it.
+ * Then, I will cast ruby VALUE to C++ value, according to type_id
+ * then I will just set apropreciated hash entry to this casted value
+ */
+static bool marshall_value(Exiv2::ExifData &data, const char* key, VALUE value) {
+	Exiv2::TypeId type_id;
+	try {
+		Exiv2::ExifKey exif_key(key);
+		type_id = Exiv2::ExifTags::tagType(exif_key.tag(), exif_key.ifdId());
+	}
+	catch(Exiv2::Error& e) {
+		rb_raise(eError, "Cannot set tag %s because it doesn't exists. Look at http://www.exiv2.org/tags.html for list of supported tags", key);
+	}
+	switch(type_id) {
+		case Exiv2::invalidTypeId:
+		{
+			rb_warn("Trying to marshall invalid type id");
+			return Qnil;
+		}
+		
+		case Exiv2::unsignedByte:
+		case Exiv2::unsignedShort:
+		case Exiv2::unsignedLong:
+		case Exiv2::signedShort:
+		case Exiv2::signedLong: 
+		{
+			data[key] = NUM2INT(value);
+			return true;
+		}
+		
+		case Exiv2::asciiString:
+		case Exiv2::string: 
+		case Exiv2::undefined:
+		{
+			data[key] = std::string(STR(value));
+			return true;
+		}
+		
+		case Exiv2::unsignedRational:
+		case Exiv2::signedRational: 
+		{
+			if(rb_respond_to(value, rb_intern("numerator"))) {
+				int numerator = NUM2INT(rb_funcall(value, rb_intern("numerator"), 0));
+				int denominator = NUM2INT(rb_funcall(value, rb_intern("denominator"), 0));
+				data[key] = Exiv2::Rational(numerator, denominator);
+				return true;
+			}
+			data[key] = Exiv2::Rational(NUM2INT(value), 1);
+			return true;
+		}
+		
+		case Exiv2::invalid6:
+		case Exiv2::date:
+		case Exiv2::time:
+		case Exiv2::comment:
+		case Exiv2::directory:
+		case Exiv2::lastTypeId:
+		{
+			data[key] = std::string(STR(value));
+			return true;
+		}
+	}
+	return false;
+}
+
 
 
 
@@ -42,9 +108,8 @@ static VALUE exiv2_exif_set(VALUE self, VALUE key, VALUE value) {
 	Data_Get_Struct(self, rbImage, image);
 
 	VALUE strkey = rb_funcall(key, rb_intern("to_s"), 0);
-	Exiv2::ExifData &exifData = image->image->exifData();
 
-	if(!marshall_value(exifData, STR(strkey), value)) {
+	if(!marshall_value(image->image->exifData(), STR(strkey), value)) {
 		THROW("Couldn't write %s", STR(strkey));
 	}
 	
@@ -157,7 +222,7 @@ static VALUE exiv2_exif_empty(VALUE self) {
 }
 
 
-
+#ifdef HAVE_IFDTAGLIST
 static void tag_leave(Exiv2::TagInfo* info) {
 	
 }
@@ -177,7 +242,6 @@ static int iterate_tag_collection(const Exiv2::TagInfo* collection, bool to_yiel
 	return i;
 }
 
-#ifdef HAVE_IFDTAGLIST
 static VALUE exiv2_tags_each(VALUE self) {
 	__BEGIN
 	iterate_tag_collection(Exiv2::ExifTags::ifdTagList());

data/ext/exiv2.hpp

@@ -102,9 +102,9 @@ struct rbImage {
 	Exiv2::Image::AutoPtr image;
 };
 
-bool marshall_value(Exiv2::ExifData &exifData, const char* key, VALUE value);
 VALUE unmarshall_value(const Exiv2::Value& value);
 
+
 void Init_image();
 void Init_exif();
 void Init_iptc();

data/ext/extconf.rb

@@ -1,14 +1,25 @@
 #!/usr/bin/env ruby
 
 require "mkmf"
+require 'optparse'
 CONFIG["CPP"] = "g++ -E "
 CONFIG["CC"] = "g++  "
+CONFIG["LDSHARED"].gsub!(/^cc /,"g++ ")
+
+
+$CPPFLAGS << " -Wall -I/usr/include/exiv2 "
+$LDFLAGS << " -lstdc++ "
+
+OptionParser.new do |opts|
+  opts.on("-E PATH", "--exiv2-dir=PATH", "Prefix, where libexiv2 is installed: /usr/local") do |path|
+    $LDFLAGS << "-L" + path + "/lib "
+    $CPPFLAGS << "-I" + path + "/include "
+    $CPPFLAGS << "-I" + path + "/include/exiv2 "
+  end
+  opts.parse!(ARGV.include?("--") ? ARGV[ARGV.index("--")+1..-1] : ARGV.clone)
+end
 
 
-#
-# -I/usr/local/include/exiv2
-$CPPFLAGS << " -Wall -I/usr/include/exiv2 -I/Users/max/Sites/exif/include/exiv2 "
-$LDFLAGS << " -lstdc++ -L/Users/max/Sites/exif/lib "
 have_header "exif.hpp"
 
 

data/ext/iptc.cpp

@@ -1,5 +1,70 @@
 #include "exiv2.hpp"
 
+/*
+ * First, I have to get out type by key. If such key is forbidden, I will refuse to marshall it.
+ * Then, I will cast ruby VALUE to C++ value, according to type_id
+ * then I will just set apropreciated hash entry to this casted value
+ */
+static bool marshall_value(Exiv2::IptcData &data, const char* key, VALUE value) {
+	Exiv2::TypeId type_id;
+	try {
+		Exiv2::IptcKey iptcKey(key);
+		type_id = Exiv2::IptcDataSets::dataSetType(iptcKey.tag(), iptcKey.record());
+	}
+	catch(Exiv2::Error& e) {
+		rb_raise(eError, "Cannot set tag %s because it doesn't exists. Look at http://www.exiv2.org/tags.html for list of supported tags", key);
+	}
+	switch(type_id) {
+		case Exiv2::invalidTypeId:
+		{
+			rb_warn("Trying to marshall invalid type id");
+			return Qnil;
+		}
+		
+		case Exiv2::unsignedByte:
+		case Exiv2::unsignedShort:
+		case Exiv2::unsignedLong:
+		case Exiv2::signedShort:
+		case Exiv2::signedLong: 
+		{
+			data[key] = NUM2INT(value);
+			return true;
+		}
+		
+		case Exiv2::asciiString:
+		case Exiv2::string: 
+		case Exiv2::undefined:
+		{
+			data[key] = std::string(STR(value));
+			return true;
+		}
+		
+		case Exiv2::unsignedRational:
+		case Exiv2::signedRational: 
+		{
+			if(rb_respond_to(value, rb_intern("numerator"))) {
+				int numerator = NUM2INT(rb_funcall(value, rb_intern("numerator"), 0));
+				int denominator = NUM2INT(rb_funcall(value, rb_intern("denominator"), 0));
+				data[key] = numerator / denominator;
+				return true;
+			}
+			data[key] = int(NUM2INT(value));
+			return true;
+		}
+		
+		case Exiv2::invalid6:
+		case Exiv2::date:
+		case Exiv2::time:
+		case Exiv2::comment:
+		case Exiv2::directory:
+		case Exiv2::lastTypeId:
+		{
+			data[key] = std::string(STR(value));
+			return true;
+		}
+	}
+	return false;
+}
 
 
 /*
@@ -29,7 +94,7 @@ static VALUE exiv2_iptc_get(VALUE self, VALUE key) {
 	__NIL_END
 }
 
-#if 0
+#if 1
 /*
  *  @iptc["Iptc.Application2.ObjectName"] = "GreeenDude"
  * [] — is a universal accessor
@@ -40,15 +105,15 @@ static VALUE exiv2_iptc_set(VALUE self, VALUE key, VALUE value) {
 	Data_Get_Struct(self, rbImage, image);
 
 	VALUE strkey = rb_funcall(key, rb_intern("to_s"), 0);
-	Exiv2::IptcData &iptcData = image->image->iptcData();
 
-	if(!marshall_value(iptcData, STR(strkey), value)) {
+	if(!marshall_value(image->image->iptcData(), STR(strkey), value)) {
 		THROW("Couldn't write %s", STR(strkey));
 	}
 	
 	image->dirty = true;
 	return value;
 	__NIL_END
+	
 }
 #endif
 
@@ -72,7 +137,6 @@ static VALUE exiv2_iptc_each(int argc, VALUE *argv, VALUE self) {
 	for(Exiv2::IptcData::const_iterator i = iptcData.begin(); i != end; ++i) {
 		VALUE key = rb_str_new(i->key().c_str(), i->key().length());
 		VALUE val = unmarshall_value(i->value());
-		//VALUE val = rb_str_new(i->toString().c_str(), i->toString().length());
 		if(prefix != Qnil && INT2FIX(0) != rb_funcall(key, rb_intern("index"), 1, prefix)) {
 			continue;
 		}
@@ -82,7 +146,7 @@ static VALUE exiv2_iptc_each(int argc, VALUE *argv, VALUE self) {
 	__END
 }
 
-#if 0
+#if 1
 /*
  * Delete iptc value by it's name
  */
@@ -165,7 +229,7 @@ void Init_iptc() {
 	cIptc = rb_define_class_under(mExiv2, "Iptc", rb_cObject);
 	rb_define_method(cIptc, "each", VALUEFUNC(exiv2_iptc_each), -1);
 	rb_define_method(cIptc, "[]", VALUEFUNC(exiv2_iptc_get), 1);
-#if 0
+#if 1
 	rb_define_method(cIptc, "[]=", VALUEFUNC(exiv2_iptc_set), 2);
 	rb_define_method(cIptc, "delete", VALUEFUNC(exiv2_iptc_delete), 1);
 #endif

data/ext/marshall.cpp

@@ -1,42 +1,48 @@
 #include "exiv2.hpp"
 
 
-typedef VALUE (unmarshaller)(const Exiv2::Value& value, long pos = 0);
+class Unmarshaller {
+public:
+	virtual VALUE unmarshall(const Exiv2::Value& value, long pos = 0) = 0;
+	virtual ~Unmarshaller() {};
+};
 
-static VALUE unmarshall_long_value(const Exiv2::Value& value, long pos = 0) {
-	return INT2NUM(value.toLong(pos));
-}
-
-
-static VALUE unmarshall_rational_value(const Exiv2::Value& value, long pos = 0) {
-	Exiv2::Rational r = value.toRational(pos);
-	ID rational_id = rb_intern("Rational");
-	if(rb_const_defined(rb_cObject, rational_id)) {
-		VALUE rational = rb_const_get(rb_cObject, rational_id);
-		return rb_funcall(rational, rb_intern("new!"), 2, INT2NUM(r.first), INT2NUM(r.second));
+class unmarshall_long_value : public Unmarshaller {
+public:
+	virtual VALUE unmarshall(const Exiv2::Value& value, long pos = 0) {
+		return INT2NUM(value.toLong(pos));
 	}
-	return INT2NUM(r.first/r.second);
-	
-}
+};
 
+class unmarshall_rational_value : public Unmarshaller {
+public:
+	virtual VALUE unmarshall(const Exiv2::Value& value, long pos = 0) {
+		Exiv2::Rational r = value.toRational(pos);
+		ID rational_id = rb_intern("Rational");
+		if(rb_const_defined(rb_cObject, rational_id)) {
+			VALUE rational = rb_const_get(rb_cObject, rational_id);
+			return rb_funcall(rational, rb_intern("new!"), 2, INT2NUM(r.first), INT2NUM(r.second));
+		}
+		return INT2NUM(r.first/r.second);
+	}
+};
 
-static VALUE unmarshall_multiple_values(const Exiv2::Value& value, unmarshaller f) {
+static VALUE unmarshall_multiple_values(const Exiv2::Value& value, Unmarshaller& f) {
 	if(value.count() <= 0) {
 		rb_warn("Empty value (no entries)");
 		return Qnil;
 	}
-	
+
 
 	if(value.count() == 1) {
-		return f(value);
+		return f.unmarshall(value);
 	}
-	
+
 	VALUE retval = rb_ary_new2(value.count());
 	for(int i = 0; i < value.count(); i++) {
-		rb_ary_store(retval, i, f(value, i));
+		rb_ary_store(retval, i, f.unmarshall(value, i));
 	}
 	return retval;
-	
 }
 
 
@@ -59,7 +65,8 @@ VALUE unmarshall_value(const Exiv2::Value& value) {
 		case Exiv2::signedShort:
 		case Exiv2::signedLong: 
 		{
-			return unmarshall_multiple_values(value, unmarshall_long_value);
+			unmarshall_long_value m;
+			return unmarshall_multiple_values(value, m);
 		}
 		
 		case Exiv2::asciiString:
@@ -73,7 +80,8 @@ VALUE unmarshall_value(const Exiv2::Value& value) {
 		case Exiv2::unsignedRational:
 		case Exiv2::signedRational: 
 		{
-			return unmarshall_multiple_values(value, unmarshall_rational_value);
+			unmarshall_rational_value m;
+			return unmarshall_multiple_values(value, m);
 			
 			Exiv2::Rational r = value.toRational();
 			ID rational_id = rb_intern("Rational");
@@ -103,68 +111,4 @@ VALUE unmarshall_value(const Exiv2::Value& value) {
 	return Qfalse;
 }
 
-/*
- * First, I have to get out type by key. If such key is forbidden, I will refuse to marshall it.
- * Then, I will cast ruby VALUE to C++ value, according to type_id
- * then I will just set apropreciated hash entry to this casted value
- */
-bool marshall_value(Exiv2::ExifData &exifData, const char* key, VALUE value) {
-	Exiv2::TypeId type_id;
-	try {
-		Exiv2::ExifKey exif_key(key);
-		type_id = Exiv2::ExifTags::tagType(exif_key.tag(), exif_key.ifdId());
-	}
-	catch(Exiv2::Error& e) {
-		rb_raise(eError, "Cannot set tag %s because it doesn't exists. Look at http://www.exiv2.org/tags.html for list of supported tags", key);
-	}
-	switch(type_id) {
-		case Exiv2::invalidTypeId:
-		{
-			rb_warn("Trying to marshall invalid type id");
-			return Qnil;
-		}
-		
-		case Exiv2::unsignedByte:
-		case Exiv2::unsignedShort:
-		case Exiv2::unsignedLong:
-		case Exiv2::signedShort:
-		case Exiv2::signedLong: 
-		{
-			exifData[key] = NUM2INT(value);
-			return true;
-		}
-		
-		case Exiv2::asciiString:
-		case Exiv2::string: 
-		case Exiv2::undefined:
-		{
-			exifData[key] = std::string(STR(value));
-			return true;
-		}
-		
-		case Exiv2::unsignedRational:
-		case Exiv2::signedRational: 
-		{
-			if(rb_respond_to(value, rb_intern("numerator"))) {
-				int numerator = NUM2INT(rb_funcall(value, rb_intern("numerator"), 0));
-				int denominator = NUM2INT(rb_funcall(value, rb_intern("denominator"), 0));
-				exifData[key] = Exiv2::Rational(numerator, denominator);
-				return true;
-			}
-			exifData[key] = Exiv2::Rational(NUM2INT(value), 1);
-			return true;
-		}
-		
-		case Exiv2::invalid6:
-		case Exiv2::date:
-		case Exiv2::time:
-		case Exiv2::comment:
-		case Exiv2::directory:
-		case Exiv2::lastTypeId:
-		{
-			exifData[key] = std::string(STR(value));
-			return true;
-		}
-	}
-	return false;
-}
+

data/lib/exiv2.rb

@@ -1,2 +1,21 @@
-require File.dirname(__FILE__)+'/exiv2_bin'
+begin
+  require File.dirname(__FILE__)+'/exiv2_bin'
+rescue LoadError
+  require File.dirname(__FILE__)+'/../ext/exiv2_bin'
+end
 
+module Exiv2
+  class Image
+    
+    def [](key)
+      return exif[key] if key[0...4] == "Exif"
+      return iptc[key] if key[0...4] == "Iptc"
+    end
+    
+    def []=(key, value)
+      return exif[key] = value if key[0...4] == "Exif"
+      return iptc[key] = value if key[0...4] == "Iptc"
+      raise Exiv2::Error, "Unknown key for writing: #{key.inspect}"
+    end
+  end
+end

data/test/image.rb

@@ -25,56 +25,56 @@ class ImageTest < Test::Unit::TestCase
     open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
       open(filename) do |image_file|
         assert @img = Exiv2::Image.new(image_file), "Image should be opened from IO::File"
-        assert_equal "FinePixS2Pro", @img.exif["Exif.Image.Model"]
-        assert_equal nil, @img.exif["zeze"]
+        assert_equal "FinePixS2Pro", @img["Exif.Image.Model"]
+        assert_equal nil, @img["zeze"]
         assert_raise(Exiv2::Error, "Setting of invalid tag should raise an exception") do
-          @img.exif["zeze"] = "lala"
+          @img["zeze"] = "lala"
         end
-        assert_equal 3024, @img.exif["Exif.Photo.PixelXDimension"]
+        assert_equal 3024, @img["Exif.Photo.PixelXDimension"]
       end
     end
     
     open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
       assert @img = Exiv2::Image.new(filename), "Image should be opened from filename"
-      assert_equal "FinePixS2Pro", @img.exif["Exif.Image.Model"]
-      assert_equal nil, @img.exif["zeze"]
-      assert_equal 3024, @img.exif["Exif.Photo.PixelXDimension"]
+      assert_equal "FinePixS2Pro", @img["Exif.Image.Model"]
+      assert_equal nil, @img["zeze"]
+      assert_equal 3024, @img["Exif.Photo.PixelXDimension"]
     end
   end
   
   def test_write_string
     open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
       assert @img = Exiv2::Image.new(filename)
-      assert_equal "FinePixS2Pro", @img.exif["Exif.Image.Model"]
-      assert_equal "*istDs", @img.exif["Exif.Image.Model"] = "*istDs"
+      assert_equal "FinePixS2Pro", @img["Exif.Image.Model"]
+      assert_equal "*istDs", @img["Exif.Image.Model"] = "*istDs"
       assert @img.save
 
       assert @img = Exiv2::Image.new(filename)
-      assert_equal "*istDs", @img.exif["Exif.Image.Model"]
+      assert_equal "*istDs", @img["Exif.Image.Model"]
     end
   end
 
   def test_write_int
     open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
       assert @img = Exiv2::Image.new(filename)
-      assert_equal 3024, @img.exif["Exif.Photo.PixelXDimension"]
-      assert_equal 25, @img.exif["Exif.Photo.PixelXDimension"] = 25
+      assert_equal 3024, @img["Exif.Photo.PixelXDimension"]
+      assert_equal 25, @img["Exif.Photo.PixelXDimension"] = 25
       assert @img.save
 
       assert @img = Exiv2::Image.new(filename)
-      assert_equal 25, @img.exif["Exif.Photo.PixelXDimension"]
+      assert_equal 25, @img["Exif.Photo.PixelXDimension"]
     end
   end
 
   def test_write_rational
     open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
       assert @img = Exiv2::Image.new(filename)
-      assert_equal Rational.new!(72, 1), @img.exif["Exif.Image.XResolution"]
-      assert_equal Rational.new!(27, 11), @img.exif["Exif.Image.XResolution"] = Rational.new!(27, 11)
+      assert_equal Rational.new!(72, 1), @img["Exif.Image.XResolution"]
+      assert_equal Rational.new!(27, 11), @img["Exif.Image.XResolution"] = Rational.new!(27, 11)
       assert @img.save
 
       assert @img = Exiv2::Image.new(filename)
-      assert_equal Rational.new!(27, 11), @img.exif["Exif.Image.XResolution"]
+      assert_equal Rational.new!(27, 11), @img["Exif.Image.XResolution"]
     end
   end
 
@@ -84,7 +84,7 @@ class ImageTest < Test::Unit::TestCase
       assert @img = Exiv2::Image.new(filename)
 
       assert_raise(TypeError, "Setting of non-convertable values should raise an TypeError") do
-        @img.exif["Exif.Image.XResolution"] = "lala"
+        @img["Exif.Image.XResolution"] = "lala"
       end
     end
   end
@@ -141,14 +141,14 @@ class ImageTest < Test::Unit::TestCase
   def test_read_undefined
     open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
       assert @img = Exiv2::Image.new(filename)
-      assert_equal "48 49 48 48 ", @img.exif["Exif.Iop.InteroperabilityVersion"]
+      assert_equal "48 49 48 48 ", @img["Exif.Iop.InteroperabilityVersion"]
     end
   end
 
   def test_read_ascii
     open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
       assert @img = Exiv2::Image.new(filename)
-      assert_equal "R98", @img.exif["Exif.Iop.InteroperabilityIndex"]
+      assert_equal "R98", @img["Exif.Iop.InteroperabilityIndex"]
     end
   end
   
@@ -163,8 +163,8 @@ class ImageTest < Test::Unit::TestCase
     open_test_file "gps-test.jpg" do |filename|
       assert @img = Exiv2::Image.new(filename)
       require 'rational'
-      assert_equal [Rational.new!(41, 1), Rational.new!(53, 1), Rational.new!(4091, 100)], @img.exif["Exif.GPSInfo.GPSLatitude"]
-      assert_equal [Rational.new!(12, 1), Rational.new!(28, 1), Rational.new!(5996, 100)], @img.exif["Exif.GPSInfo.GPSLongitude"]
+      assert_equal [Rational.new!(41, 1), Rational.new!(53, 1), Rational.new!(4091, 100)], @img["Exif.GPSInfo.GPSLatitude"]
+      assert_equal [Rational.new!(12, 1), Rational.new!(28, 1), Rational.new!(5996, 100)], @img["Exif.GPSInfo.GPSLongitude"]
     end
   end
   
@@ -186,7 +186,18 @@ class ImageTest < Test::Unit::TestCase
   def test_iptc_get
     open_test_file "smiley1.jpg" do |filename|
       assert @img = Exiv2::Image.new(filename)
-      assert_equal "Seattle", @img.iptc["Iptc.Application2.City"]
+      assert_equal "Seattle", @img["Iptc.Application2.City"]
+    end
+  end
+
+  def test_iptc_get
+    open_test_file "smiley1.jpg" do |filename|
+      assert @img = Exiv2::Image.new(filename)
+      assert_equal "Moscow", @img["Iptc.Application2.City"] = "Moscow"
+      assert @img.save
+      
+      assert @img = Exiv2::Image.new(filename)
+      assert_equal "Moscow", @img["Iptc.Application2.City"]
     end
   end
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.0
 specification_version: 1
 name: ruby-exiv2
 version: !ruby/object:Gem::Version 
-  version: "0.6"
-date: 2007-01-06 00:00:00 +03:00
+  version: "0.7"
+date: 2007-02-19 00:00:00 +03:00
 summary: Exiv2 (exif image tags handling) library driver
 require_paths: 
 - lib
@@ -25,6 +25,7 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Max Lapshin
 files: