ruby-exiv2 0.2 → 0.3

data/README

@@ -0,0 +1,12 @@
+Library for handling exif image tags.
+
+Basic usage:
+
+> gem install ruby-exiv2
+
+
+require 'exiv2'
+@img = Exiv2::Image.new("a.jpg")
+@exif = @img.exif
+puts @img.exif["Exif.Photo.PixelXDimension"]
+=> 3024

data/lib/Makefile

@@ -40,7 +40,7 @@ CFLAGS   =  -fno-common -O -pipe -I/opt/local/include  -fno-common -pipe -fno-co
 CPPFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir) -DHAVE_EXIF_HPP -O -pipe -I/opt/local/include -Wall -I/usr/local/include/exiv2 -I/usr/include/exiv2 
 CXXFLAGS = $(CFLAGS) 
 DLDFLAGS = -L/opt/local/lib -lstdc++   
-LDSHARED = g++ -g  -dynamic -bundle -undefined suppress -flat_namespace
+LDSHARED = cc -dynamic -bundle -undefined suppress -flat_namespace
 AR = ar
 EXEEXT = 
 

data/lib/exif.cpp

@@ -9,7 +9,7 @@ static VALUE unmarshall_value(const Exiv2::Value& value) {
 	
 	Exiv2::TypeId type_id = value.typeId();
 	switch(type_id) {
-		case Exiv2::invalidTypeId: 
+		case Exiv2::invalidTypeId:
 		{
 			rb_warn("Trying to demarshall invalid type id");
 			return Qnil;
@@ -31,16 +31,17 @@ static VALUE unmarshall_value(const Exiv2::Value& value) {
 			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: 
 		{
-			return rb_str_new2(value.toString().c_str());
 			Exiv2::Rational r = value.toRational();
 			ID rational_id = rb_intern("Rational");
-			if(0 && rb_const_defined(rb_cObject, rational_id)) {
+			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));
 			}
@@ -95,6 +96,67 @@ static VALUE exiv2_exif_get(VALUE self, VALUE key) {
 	__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::ExifKey exif_key(key);
+	Exiv2::TypeId type_id = Exiv2::ExifTags::tagType(exif_key.tag(), exif_key.ifdId());
+	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;
+}
+
+
 /*
  *  @exif["Exif.Photo.PixelXDimension"] = 3024
  * [] — is a universal accessor
@@ -105,12 +167,19 @@ 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);
-	VALUE strvalue = rb_funcall(value, rb_intern("to_s"), 0);
-	Exiv2::ExifData &exifData = image->image->exifData();
+	bool marshalled = false;
+	{
+		Exiv2::ExifData &exifData = image->image->exifData();
+
+		marshalled = marshall_value(exifData, STR(strkey), value);
+	}
+	
+	if(!marshalled) {
+		THROW("Couldn't write %s", STR(strkey));
+	}
 
-	exifData[STR(strkey)] = STR(strvalue);
 	image->dirty = true;
-	return strvalue;
+	return value;
 	__NIL_END
 }
 

data/lib/exiv2.cpp

@@ -31,11 +31,26 @@
 
 VALUE mExiv2, cImage, cExif, cIptc, cThumbnail, eError;
 
+void rb_exiv2_throw(const char *file, long unsigned int line, const char *fmt, ...) {
+	char* message;
+	va_list ap;
+	va_start(ap, fmt);
+	vasprintf(&message, fmt, ap);
+	va_end(ap);
+	
+	char error_message[strlen(message) + 80];
+	snprintf(error_message, sizeof(error_message), "%s. File: %s, line: %lu", message, file, line);
+	free(message);
+	rb_raise(eError, error_message);
+}
+
+
 #ifdef __cplusplus
 extern "C"
 #endif
 
 
+
 void Init_exiv2() {
 	mExiv2 = rb_define_module("Exiv2");
 	

data/lib/exiv2.hpp

@@ -81,6 +81,9 @@
 #define __NIL_END } catch(Exiv2::AnyError& e) { return Qnil; }
 #define __VOID_END } catch(Exiv2::AnyError& e) {}
 
+#define THROW(message, ...) rb_exiv2_throw(__FILE__, __LINE__, message, ##__VA_ARGS__)
+void rb_exiv2_throw(const char* file, long unsigned int line, const char *fmt, ...);
+
 #if defined(__cplusplus)
 extern "C" {
 #endif

data/lib/extconf.rb

@@ -1,8 +1,9 @@
 #!/usr/bin/env ruby
 
 require "mkmf"
-CONFIG["CPP"] = "g++ -g -undefined suppress -flat_namespace "
-CONFIG['LDSHARED'] = "g++ -g  -dynamic -bundle -undefined suppress -flat_namespace"
+#CONFIG["CXX"] = "g++ -g " + CONFIG['LDSHARED']
+CONFIG["CPP"] = "g++ -E "
+#CONFIG['LDSHARED'] = "g++ -g  -dynamic -bundle -undefined suppress -flat_namespace"
 
 
 

data/test/image.rb

@@ -14,71 +14,99 @@ class ImageTest < Test::Unit::TestCase
     end
     begin
       yield test_file_name
-    rescue
+    rescue StandardError => e
+      File.unlink(test_file_name)
+      raise e
     end
     File.unlink(test_file_name)
   end
   
   def test_open
-    open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |f|
-      assert @img = Exiv2::Image.new(f), "Image should be opened from IO::File"
-      assert_equal "FinePixS2Pro", @img.exif["Exif.Image.Model"]
-      assert_equal nil, @img.exif["zeze"]
-      assert_equal "3024", @img.exif["Exif.Photo.PixelXDimension"]
+    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 3024, @img.exif["Exif.Photo.PixelXDimension"]
+      end
     end
     
-    open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |f|
-      assert @img = Exiv2::Image.new(f.path), "Image should be opened from filename"
+    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 3024, @img.exif["Exif.Photo.PixelXDimension"]
     end
   end
   
-  def test_write
-    open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |f|
-      assert @img = Exiv2::Image.new(f)
+  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 @img.save
 
-      assert @img = Exiv2::Image.new(f)
+      assert @img = Exiv2::Image.new(filename)
       assert_equal "*istDs", @img.exif["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 @img.save
+
+      assert @img = Exiv2::Image.new(filename)
+      assert_equal 25, @img.exif["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 @img.save
+
+      assert @img = Exiv2::Image.new(filename)
+      assert_equal Rational.new!(27, 11), @img.exif["Exif.Image.XResolution"]
+    end
+  end
+
+
+
   def test_comment
-    open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |f|
-      assert @img = Exiv2::Image.new(f)
+    open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
+      assert @img = Exiv2::Image.new(filename)
       assert_equal "My funny comment", @img.comment = "My funny comment"
       assert @img.save
 
-      assert @img = Exiv2::Image.new(f)
+      assert @img = Exiv2::Image.new(filename)
       assert_equal "My funny comment", @img.comment
     end
   end
   
   def test_typehinting
-    open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |f|
-      assert @img = Exiv2::Image.new(f)
+    open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
+      assert @img = Exiv2::Image.new(filename)
       assert @exif = @img.exif
       assert_equal 1, @exif["Exif.Image.Orientation"]
       assert_equal "Digital Camera FinePixS2Pro Ver1.00", @exif["Exif.Image.Software"]
+      assert_kind_of Numeric, @exif["Exif.Image.XResolution"]
       assert_equal 72, @exif["Exif.Image.XResolution"]
-      assert_equal String, @exif["Exif.Image.XResolution"].class
-      puts @exif["Exif.Image.XResolution"].class
 
       require 'rational'
 
-      assert_equal 72, @exif["Exif.Image.XResolution"]
-      assert_equal Numeric, @exif["Exif.Image.XResolution"].class
-      puts @exif["Exif.Image.XResolution"].class
+      assert_kind_of Rational, @exif["Exif.Image.XResolution"]
+      assert_equal Rational.new!(72, 1), @exif["Exif.Image.XResolution"]
     end
   end
 
   def test_each
-    open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |f|
-      assert @img = Exiv2::Image.new(f)
+    open_test_file "exiv2-fujifilm-finepix-s2pro.jpg" do |filename|
+      assert @img = Exiv2::Image.new(filename)
       i = 0
       @img.exif.each do |key, value|
         i = i + 1

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ruby-exiv2
 version: !ruby/object:Gem::Version 
-  version: "0.2"
-date: 2006-10-30 00:00:00 +03:00
+  version: "0.3"
+date: 2006-11-07 00:00:00 +03:00
 summary: Exiv2 (exif image tags handling) library driver
 require_paths: 
 - lib