ruby-exiv2 0.4 → 0.5

data/lib/Makefile

@@ -4,7 +4,7 @@ SHELL = /bin/sh
 #### Start of system configuration section. ####
 
 srcdir = .
-topdir = /opt/local/lib/ruby/1.8/powerpc-darwin8.8.0
+topdir = /opt/local/lib/ruby/1.8/i686-darwin8.8.3
 hdrdir = $(topdir)
 VPATH = $(srcdir):$(topdir):$(hdrdir)
 prefix = $(DESTDIR)/opt/local
@@ -30,7 +30,7 @@ vendorlibdir = $(vendordir)/$(ruby_version)
 sitelibdir = $(sitedir)/$(ruby_version)
 libexecdir = $(exec_prefix)/libexec
 
-CC = gcc
+CC = g++ -c 
 LIBRUBY = $(LIBRUBY_SO)
 LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
 LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
@@ -38,19 +38,19 @@ LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
 
 RUBY_EXTCONF_H = 
 CFLAGS   =  -fno-common -O -pipe -I/opt/local/include  -fno-common -pipe -fno-common 
-INCFLAGS = -I. -I. -I/opt/local/lib/ruby/1.8/powerpc-darwin8.8.0 -I.
-CPPFLAGS =  -O -pipe -I/opt/local/include -Wall -I/usr/local/include/exiv2 -I/usr/include/exiv2 
+INCFLAGS = -I. -I. -I/opt/local/lib/ruby/1.8/i686-darwin8.8.3 -I.
+CPPFLAGS = -DHAVE_EXIF_HPP -O -pipe -I/opt/local/include -Wall -I/usr/include/exiv2 -I/Users/max/Sites/exif/include/exiv2 
 CXXFLAGS = $(CFLAGS) 
-DLDFLAGS = -L/opt/local/lib -lstdc++   
+DLDFLAGS = -L/opt/local/lib -lstdc++ -L/Users/max/Sites/exif/lib   
 LDSHARED = cc -dynamic -bundle -undefined suppress -flat_namespace
 AR = ar
 EXEEXT = 
 
 RUBY_INSTALL_NAME = ruby
 RUBY_SO_NAME = ruby
-arch = powerpc-darwin8.8.0
-sitearch = powerpc-darwin8.8.0
-vendorarch = powerpc-darwin8.8.0
+arch = i686-darwin8.8.3
+sitearch = i686-darwin8.8.3
+vendorarch = i686-darwin8.8.3
 ruby_version = 1.8
 ruby = /opt/local/bin/ruby
 RUBY = $(ruby)
@@ -76,7 +76,7 @@ extout =
 extout_prefix = 
 target_prefix = 
 LOCAL_LIBS = 
-LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lobjc  
+LIBS = $(LIBRUBYARG_SHARED) -lexiv2  -lpthread -ldl -lobjc  
 SRCS = exif.cpp exiv2.cpp image.cpp
 OBJS = exif.o exiv2.o image.o
 TARGET = exiv2

data/lib/exif.cpp

@@ -1,71 +1,7 @@
 #include "exiv2.hpp"
 
 
-static VALUE unmarshall_value(const Exiv2::Value& value) {
-	if(value.count() <= 0) {
-		rb_warn("Empty value (no entries)");
-		return Qnil;
-	}
-	
-	Exiv2::TypeId type_id = value.typeId();
-	switch(type_id) {
-		case Exiv2::invalidTypeId:
-		{
-			rb_warn("Trying to demarshall invalid type id");
-			return Qnil;
-		}
-		
-		case Exiv2::unsignedByte:
-		case Exiv2::unsignedShort:
-		case Exiv2::unsignedLong:
-		case Exiv2::signedShort:
-		case Exiv2::signedLong: 
-		{
-			return INT2NUM(value.toLong());
-		}
-		
-		case Exiv2::asciiString:
-		case Exiv2::string: 
-		case Exiv2::undefined:
-		{
-			VALUE str = rb_str_buf_new(value.size() - 1);
-			value.copy((Exiv2::byte *)STR(str), Exiv2::littleEndian);
-			LEN(str) = value.size() - 1;
-			STR(str)[LEN(str)] = '\0';
-			LEN(str) = strlen(STR(str));
-			return str;
-		}
-		
-		case Exiv2::unsignedRational:
-		case Exiv2::signedRational: 
-		{
-			Exiv2::Rational r = value.toRational();
-			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);
-		}
-		
-		case Exiv2::invalid6:
-		case Exiv2::date:
-		case Exiv2::time:
-		case Exiv2::comment:
-		case Exiv2::directory:
-		case Exiv2::lastTypeId:
-		{
-			VALUE str = rb_str_buf_new(value.size() - 1);
-			value.copy((Exiv2::byte *)STR(str), Exiv2::littleEndian);
-			LEN(str) = value.size() - 1;
-			char msg[200];
-			snprintf(msg, sizeof(msg), " !!! %d", type_id);
-			rb_funcall(str, rb_intern("<<"), 1, rb_str_new2(msg));
-			return str;
-		}
-	}
-	return Qfalse;
-}
+
 
 /*
  * Access exif tag by name
@@ -91,76 +27,9 @@ static VALUE exiv2_exif_get(VALUE self, VALUE key) {
     }
 	
 	return unmarshall_value(pos->value());
-	//std::string v = pos->toString();
-	//return rb_str_new(v.c_str(), v.length());
 	__NIL_END
 }
 
-/*
- * 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 &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;
-}
 
 
 /*
@@ -197,7 +66,7 @@ static VALUE exiv2_exif_each(int argc, VALUE *argv, VALUE self) {
 	
 	Exiv2::ExifData &exifData = image->image->exifData();
 	if(exifData.empty()) {
-		return self;
+		return Qnil;
 	}
 	
 	Exiv2::ExifData::const_iterator end = exifData.end();
@@ -288,36 +157,96 @@ static VALUE exiv2_exif_empty(VALUE self) {
 }
 
 
-/*
+
 static void tag_leave(Exiv2::TagInfo* info) {
 	
 }
 
-static VALUE create_exiv2_tag(VALUE exif, Exiv2::TagInfo* info) {
-	VALUE tag_info = Data_Wrap_Struct(cTag, 0, tag_leave, info);
-	rb_iv_set(tag_info, "@exif", exif);
-	return tag_info;
+static VALUE create_exiv2_tag(Exiv2::TagInfo* info) {
+	return Data_Wrap_Struct(cTag, 0, tag_leave, info);
 }
-static VALUE exiv2_exif_tags_each(VALUE self) {
-    for (int i=0; Exiv2::ifdTagInfo[i].tag_ != 0xffff; ++i) {
-		rb_yield(create_exiv2_tag(self, Exiv2::ifdTagInfo + i));
-    }
-    for (int i=0; Exiv2::exifTagInfo[i].tag_ != 0xffff; ++i) {
-		rb_yield(create_exiv2_tag(self, Exiv2::exifTagInfo + i));
-    }
-    for (int i=0; Exiv2::iopTagInfo[i].tag_ != 0xffff; ++i) {
-		rb_yield(create_exiv2_tag(self, Exiv2::iopTagInfo + i));
-    }
-    for (int i=0; Exiv2::gpsTagInfo[i].tag_ != 0xffff; ++i) {
-		rb_yield(create_exiv2_tag(self, Exiv2::gpsTagInfo + i));
+
+static int iterate_tag_collection(const Exiv2::TagInfo* collection, bool to_yield = true) {
+	Exiv2::TagInfo* _collection = const_cast<Exiv2::TagInfo *>(collection);
+	int i;
+    for (i=0; _collection[i].tag_ != 0xffff; ++i) {
+		if(to_yield) {
+			rb_yield(create_exiv2_tag(_collection + i));
+		}
     }
+	return i;
+}
+
+#ifdef HAVE_IFDTAGLIST
+static VALUE exiv2_tags_each(VALUE self) {
+	__BEGIN
+	iterate_tag_collection(Exiv2::ExifTags::ifdTagList());
+	iterate_tag_collection(Exiv2::ExifTags::exifTagList());
+	iterate_tag_collection(Exiv2::ExifTags::iopTagList());
+	iterate_tag_collection(Exiv2::ExifTags::gpsTagList());
 	return self;
+	__END
+}
+
+
+
+static VALUE exiv2_tags_count(VALUE self) {
+	__BEGIN
+	return INT2NUM(
+	iterate_tag_collection(Exiv2::ExifTags::ifdTagList(), false) +
+	iterate_tag_collection(Exiv2::ExifTags::exifTagList(), false) +
+	iterate_tag_collection(Exiv2::ExifTags::iopTagList(), false) +
+	iterate_tag_collection(Exiv2::ExifTags::gpsTagList(), false)
+	);
+	__END
+}
+#endif /* HAVE_IFDTAGLIST */
+
+static VALUE exiv2_tag_name(VALUE self) {
+	__BEGIN
+	Exiv2::TagInfo* tag;
+	Data_Get_Struct(self, Exiv2::TagInfo, tag);
+	
+	return tag->name_ ? rb_str_new2(tag->name_) : Qnil;
+	__END
+}
+
+static VALUE exiv2_tag_title(VALUE self) {
+	__BEGIN
+	Exiv2::TagInfo* tag;
+	Data_Get_Struct(self, Exiv2::TagInfo, tag);
+	
+	return tag->title_ ? rb_str_new2(tag->title_) : Qnil;
+	__END
+}
+
+static VALUE exiv2_tag_desc(VALUE self) {
+	__BEGIN
+	Exiv2::TagInfo* tag;
+	Data_Get_Struct(self, Exiv2::TagInfo, tag);
+	
+	return tag->desc_ ? rb_str_new2(tag->desc_) : Qnil;
+	__END
+}
+
+static VALUE exiv2_tag_section(VALUE self) {
+	__BEGIN
+	Exiv2::TagInfo* tag;
+	Data_Get_Struct(self, Exiv2::TagInfo, tag);
+	
+	return rb_str_new2(Exiv2::ExifTags::sectionName(tag->sectionId_));
+	__END
 }
 
-static VALUE exiv2_iptc_tags_each(VALUE self) {
+static VALUE exiv2_tag_ifd(VALUE self) {
+	__BEGIN
+	Exiv2::TagInfo* tag;
+	Data_Get_Struct(self, Exiv2::TagInfo, tag);
 	
+	return rb_str_new2(Exiv2::ExifTags::ifdName(tag->ifdId_));
+	__END
 }
-*/
+
 
 void Init_exif() {
 	cExif = rb_define_class_under(mExiv2, "Exif", rb_cObject);
@@ -328,8 +257,17 @@ void Init_exif() {
 	rb_define_method(cExif, "clear", VALUEFUNC(exiv2_exif_clear), 0);
 	rb_define_method(cExif, "count", VALUEFUNC(exiv2_exif_count), 0);
 	rb_define_method(cExif, "empty?", VALUEFUNC(exiv2_exif_empty), 0);
-//	rb_define_singleton_method(cExif, "exif_tags_each", VALUEFUNC(exiv2_exif_tags_each), 0);
 //	rb_define_singleton_method(cExif, "iptc_tags_each", VALUEFUNC(exiv2_iptc_tags_each), 0);
 	
 	cTag = rb_define_class_under(mExiv2, "Tag", rb_cObject);
+#ifdef HAVE_IFDTAGLIST
+	rb_define_singleton_method(cTag, "each", VALUEFUNC(exiv2_tags_each), 0);
+	rb_define_singleton_method(cTag, "count", VALUEFUNC(exiv2_tags_count), 0);
+#endif /* HAVE_IFDTAGLIST */
+	
+	rb_define_method(cTag, "ifd", VALUEFUNC(exiv2_tag_ifd), 0);
+	rb_define_method(cTag, "section", VALUEFUNC(exiv2_tag_section), 0);
+	rb_define_method(cTag, "name", VALUEFUNC(exiv2_tag_name), 0);
+	rb_define_method(cTag, "title", VALUEFUNC(exiv2_tag_title), 0);
+	rb_define_method(cTag, "desc", VALUEFUNC(exiv2_tag_desc), 0);
 }

data/lib/exiv2.cpp

@@ -58,6 +58,7 @@ void Init_exiv2() {
 	
 	Init_image();
 	Init_exif();
+	Init_iptc();
 	//cThumbnail = rb_define_class_under(mExiv2, "Thumbnail", rb_cObject);
 	//rb_define_method(cThumbnail, "extension", VALUEFUNC(exiv2_thumb_ext), 0);
 	//rb_define_method(cThumbnail, "format", VALUEFUNC(exiv2_thumb_format), 0);

data/lib/exiv2.hpp

@@ -33,6 +33,7 @@
 // included header files
 #include <image.hpp>
 #include <exif.hpp>
+#include <iptc.hpp>
 
 
 #include <string>
@@ -101,9 +102,12 @@ 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();
 
 
 #endif /* EXIV2_HPP_ */

data/lib/extconf.rb

@@ -1,15 +1,40 @@
 #!/usr/bin/env ruby
 
 require "mkmf"
-#CONFIG["CXX"] = "g++ -g " + CONFIG['LDSHARED']
 CONFIG["CPP"] = "g++ -E "
-#CONFIG['LDSHARED'] = "g++ -g  -dynamic -bundle -undefined suppress -flat_namespace"
+CONFIG["CC"] = "g++ -c "
 
 
-
-$CPPFLAGS << " -Wall -I/usr/local/include/exiv2 -I/usr/include/exiv2 "
-$LDFLAGS << " -lstdc++ "
+#
+# -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"
 have_library "exiv2", "_ZN5Exiv29MetadatumD0Ev"
+
+
+ifd_tag_list = "Exiv2::ExifTags::ifdTagList"
+def ifd_tag_list.upcase
+  "IFDTAGLIST"
+end
+have_func ifd_tag_list do <<-SRC
+  #include <image.hpp>
+  #include <exif.hpp>
+
+
+  #include <string>
+  #include <vector>
+  #include <iostream>
+  #include <fstream>
+  #include <iomanip>
+  #include <cstring>
+  #include <cassert>
+
+  #include <stdarg.h>
+int main(void) {
+  Exiv2::ExifTags::ifdTagList();
+}
+ SRC
+ end
 create_makefile 'exiv2'
 

data/lib/image.cpp

@@ -48,6 +48,24 @@ static VALUE exiv2_image_initialize(VALUE self, VALUE file) {
 	__END
 }
 
+/*
+ *
+ * Load Exiv2::Image from memory string
+ * content = File.open("a.jpg").read
+ * img = Exiv2::Image.load_string(content)
+ */
+static VALUE exiv2_image_load_string(VALUE self, VALUE string) {
+	__BEGIN
+	Check_Type(string, T_STRING);
+	rbImage* image = new rbImage();
+	image->dirty = false;
+	VALUE img = Data_Wrap_Struct(self, 0, image_delete, image);
+	
+	image->image = Exiv2::ImageFactory::open(CBSTR(string), LEN(string));
+	return img;
+	__END
+}
+
 
 static void image_real_save(rbImage* image) {
 	if(image->dirty) {
@@ -127,11 +145,24 @@ static VALUE exiv2_image_exif(VALUE self) {
 	rbImage* image;
 	Data_Get_Struct(self, rbImage, image);
 	VALUE exif = Data_Wrap_Struct(cExif, 0, image_leave, image);
-	rb_iv_set(self, "image", self);
+	rb_iv_set(exif, "@image", self);
 	return exif;
 	__END
 }
 
+/*
+ * Access to iptc data of image
+ */
+static VALUE exiv2_image_iptc(VALUE self) {
+	__BEGIN
+	rbImage* image;
+	Data_Get_Struct(self, rbImage, image);
+	VALUE iptc = Data_Wrap_Struct(cIptc, 0, image_leave, image);
+	rb_iv_set(iptc, "@image", self);
+	return iptc;
+	__END
+}
+
 
 /*
  * Dump thumbnail to file.
@@ -175,7 +206,10 @@ void Init_image() {
 	cImage = rb_define_class_under(mExiv2, "Image", rb_cObject);
 	rb_define_alloc_func(cImage, exiv2_image_s_allocate);
 	rb_define_method(cImage, "initialize", VALUEFUNC(exiv2_image_initialize), 1);
+	rb_define_singleton_method(cImage, "load_string", VALUEFUNC(exiv2_image_load_string), 1);
+	
 	rb_define_method(cImage, "exif", VALUEFUNC(exiv2_image_exif), 0);
+	rb_define_method(cImage, "iptc", VALUEFUNC(exiv2_image_iptc), 0);
 
 	rb_define_method(cImage, "thumbnail", VALUEFUNC(exiv2_image_thumbnail), 1);
 	rb_define_method(cImage, "thumbnail=", VALUEFUNC(exiv2_image_thumbnail_set), 1);

data/lib/iptc.cpp

@@ -0,0 +1,175 @@
+#include "exiv2.hpp"
+
+
+
+/*
+ * Access iptc tag by name
+ *
+ * <code>Exiv2::Image.new("test/data/smiley.jpg").iptc["Iptc.Application2.ObjectName"] => "GreeenDude"</code>
+ */
+static VALUE exiv2_iptc_get(VALUE self, VALUE key) {
+	__BEGIN
+	rbImage* image;
+	Data_Get_Struct(self, rbImage, image);
+
+	VALUE strkey = rb_funcall(key, rb_intern("to_s"), 0);
+	Exiv2::IptcData &iptcData = image->image->iptcData();
+	
+	if(iptcData.empty()) {
+		return Qnil;
+	}
+	
+    Exiv2::IptcKey iptcKey(STR(strkey));
+    Exiv2::IptcData::const_iterator pos = iptcData.findKey(iptcKey);
+    if (pos == iptcData.end()) {
+		return Qnil;
+    }
+	
+	return unmarshall_value(pos->value());
+	__NIL_END
+}
+
+#if 0
+/*
+ *  @iptc["Iptc.Application2.ObjectName"] = "GreeenDude"
+ * [] — is a universal accessor
+ */
+static VALUE exiv2_iptc_set(VALUE self, VALUE key, VALUE value) {
+	__BEGIN
+	rbImage* image;
+	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)) {
+		THROW("Couldn't write %s", STR(strkey));
+	}
+	
+	image->dirty = true;
+	return value;
+	__NIL_END
+}
+#endif
+
+/*
+ * Iterates through all iptc tags in image
+ */
+static VALUE exiv2_iptc_each(int argc, VALUE *argv, VALUE self) {
+	__BEGIN
+	rbImage* image;
+	Data_Get_Struct(self, rbImage, image);
+
+	VALUE prefix;
+	rb_scan_args(argc, argv, "01", &prefix);
+	
+	Exiv2::IptcData &iptcData = image->image->iptcData();
+	if(iptcData.empty()) {
+		return Qnil;
+	}
+	
+	Exiv2::IptcData::const_iterator end = iptcData.end();
+	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;
+		}
+		rb_yield(rb_ary_new3(2, key, val));
+	}
+	return self;
+	__END
+}
+
+#if 0
+/*
+ * Delete iptc value by it's name
+ */
+static VALUE exiv2_iptc_delete(VALUE self, VALUE key) {
+	__BEGIN
+	rbImage* image;
+	Data_Get_Struct(self, rbImage, image);
+
+	VALUE strkey = rb_funcall(key, rb_intern("to_s"), 0);
+	Exiv2::IptcData &iptcData = image->image->iptcData();
+	
+	if(iptcData.empty()) {
+		return Qnil;
+	}
+	
+    Exiv2::IptcKey iptcKey(STR(strkey));
+    Exiv2::IptcData::iterator pos = iptcData.findKey(iptcKey);
+    if (pos == iptcData.end()) {
+		return Qnil;
+    }
+	
+	std::string v = pos->toString();
+	iptcData.erase(pos);
+	return rb_str_new(v.c_str(), v.length());
+	__NIL_END
+}
+#endif
+
+/*
+ * Clear all iptc data in image
+ */
+static VALUE exiv2_iptc_clear(VALUE self) {
+	__BEGIN
+	rbImage* image;
+	Data_Get_Struct(self, rbImage, image);
+
+	Exiv2::IptcData &iptcData = image->image->iptcData();
+	
+	if(iptcData.empty()) {
+		return Qnil;
+	}
+	iptcData.clear();
+	return self;
+	__END
+}
+
+/*
+ * Count of iptc tags in image
+ */
+static VALUE exiv2_iptc_count(VALUE self) {
+	__BEGIN
+	rbImage* image;
+	Data_Get_Struct(self, rbImage, image);
+
+	Exiv2::IptcData &iptcData = image->image->iptcData();
+	
+	return INT2FIX(iptcData.count());
+	__END
+}
+
+/*
+ * Predicate method. Is iptc empty?
+ */
+static VALUE exiv2_iptc_empty(VALUE self) {
+	__BEGIN
+	rbImage* image;
+	Data_Get_Struct(self, rbImage, image);
+
+	Exiv2::IptcData &iptcData = image->image->iptcData();
+	
+	return iptcData.empty() ? Qtrue : Qfalse;
+	__NIL_END
+}
+
+
+
+
+
+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
+	rb_define_method(cIptc, "[]=", VALUEFUNC(exiv2_iptc_set), 2);
+	rb_define_method(cIptc, "delete", VALUEFUNC(exiv2_iptc_delete), 1);
+#endif
+	rb_define_method(cIptc, "clear", VALUEFUNC(exiv2_iptc_clear), 0);
+	rb_define_method(cIptc, "count", VALUEFUNC(exiv2_iptc_count), 0);
+	rb_define_method(cIptc, "empty?", VALUEFUNC(exiv2_iptc_empty), 0);
+}

data/lib/marshall.cpp

@@ -0,0 +1,170 @@
+#include "exiv2.hpp"
+
+
+typedef VALUE (unmarshaller)(const Exiv2::Value& value, long pos = 0);
+
+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));
+	}
+	return INT2NUM(r.first/r.second);
+	
+}
+
+
+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);
+	}
+	
+	VALUE retval = rb_ary_new2(value.count());
+	for(int i = 0; i < value.count(); i++) {
+		rb_ary_store(retval, i, f(value, i));
+	}
+	return retval;
+	
+}
+
+
+
+
+VALUE unmarshall_value(const Exiv2::Value& value) {
+	Exiv2::TypeId type_id = value.typeId();
+	
+	
+	switch(type_id) {
+		case Exiv2::invalidTypeId:
+		{
+			rb_warn("Trying to demarshall invalid type id");
+			return Qnil;
+		}
+		
+		case Exiv2::unsignedByte:
+		case Exiv2::unsignedShort:
+		case Exiv2::unsignedLong:
+		case Exiv2::signedShort:
+		case Exiv2::signedLong: 
+		{
+			return unmarshall_multiple_values(value, unmarshall_long_value);
+		}
+		
+		case Exiv2::asciiString:
+		case Exiv2::string: 
+		case Exiv2::undefined:
+		{
+			std::string str_value = value.toString();
+			return rb_str_new(str_value.c_str(), str_value.length());
+		}
+		
+		case Exiv2::unsignedRational:
+		case Exiv2::signedRational: 
+		{
+			return unmarshall_multiple_values(value, unmarshall_rational_value);
+			
+			Exiv2::Rational r = value.toRational();
+			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);
+		}
+		
+		case Exiv2::invalid6:
+		case Exiv2::date:
+		case Exiv2::time:
+		case Exiv2::comment:
+		case Exiv2::directory:
+		case Exiv2::lastTypeId:
+		{
+			VALUE str = rb_str_buf_new(value.size() - 1);
+			value.copy((Exiv2::byte *)STR(str), Exiv2::littleEndian);
+			LEN(str) = value.size() - 1;
+			char msg[200];
+			snprintf(msg, sizeof(msg), " !!! %d", type_id);
+			rb_funcall(str, rb_intern("<<"), 1, rb_str_new2(msg));
+			return str;
+		}
+	}
+	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/test/image.rb

@@ -129,10 +129,55 @@ class ImageTest < Test::Unit::TestCase
     end
   end
   
+  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"]
+    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"]
+    end
+  end
+  
   def __test_thumbnail
     open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
       assert @img = Exiv2::Image.new(filename)
       
     end
   end
+  
+  def test_read_multiple_rationals
+    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"]
+    end
+  end
+  
+  def test_tag_access
+    return unless Exiv2::Tag.respond_to?(:count)
+    assert_equal 139, Exiv2::Tag.count
+    exif_tag = nil
+    Exiv2::Tag.each do |tag|
+      exif_tag = tag
+      break
+    end
+    assert_equal "IFD0", exif_tag.ifd
+    assert_equal "ImageStructure", exif_tag.section
+    assert_equal "NewSubfileType", exif_tag.name
+    assert_equal "New Subfile Type", exif_tag.title
+    assert_equal "A general indication of the kind of data contained in this subfile.", exif_tag.desc
+  end
+  
+  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"]
+    end
+  end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ruby-exiv2
 version: !ruby/object:Gem::Version 
-  version: "0.4"
-date: 2006-11-09 00:00:00 +03:00
+  version: "0.5"
+date: 2006-11-20 00:00:00 +03:00
 summary: Exiv2 (exif image tags handling) library driver
 require_paths: 
 - lib
@@ -12,7 +12,7 @@ email: max@maxidoors.ru
 homepage: http://maxidoors.ru/
 rubyforge_project: ruby-exiv2
 description: 
-autorequire: intersys
+autorequire: 
 default_executable: 
 bindir: bin
 has_rdoc: true
@@ -32,12 +32,16 @@ files:
 - test/data
 - test/image.rb
 - test/data/exiv2-fujifilm-finepix-s2pro.jpg
+- test/data/gps-test.jpg
+- test/data/smiley1.jpg
 - lib/exif.cpp
 - lib/exiv2.cpp
 - lib/exiv2.hpp
 - lib/extconf.rb
 - lib/image.cpp
+- lib/iptc.cpp
 - lib/Makefile
+- lib/marshall.cpp
 - README
 test_files: []