ruby-exiv2 1.3 → 1.5

data/README

@@ -2,6 +2,7 @@ Library for handling exif image tags.
 
 Basic usage:
 
+  > gem install RubyInline
 	> gem install ruby-exiv2
 	> irb -r rubygems
 	

data/Rakefile

@@ -6,17 +6,11 @@ require 'rake/packagetask'
 require 'rake/contrib/rubyforgepublisher'
 
 PKG_NAME = "ruby-exiv2"
-PKG_VERSION = "1.3"
+PKG_VERSION = "1.5"
 PKG_AUTHOR = "Max Lapshin"
 PKG_EMAIL = "max@maxidoors.ru"
-PKG_HOMEPAGE = "http://maxidoors.ru/"
+PKG_HOMEPAGE = "http://github.com/maxlapshin/exiv2"
 PKG_SUMMARY = "Exiv2 (exif image tags handling) library driver"
-PKG_SVN = "http://svn.maxidoors.ru/ruby-exiv2"
-PKG_RDOC_OPTS = ['--main=README',
-                 '--line-numbers',
-                 '--webcvs='+PKG_SVN,
-                 '--charset=utf-8',
-                 '--promiscuous']
 
 
 spec = Gem::Specification.new do |s|
@@ -29,19 +23,16 @@ spec = Gem::Specification.new do |s|
   s.summary = PKG_SUMMARY
   s.require_path = "lib"
   s.rubyforge_project = PKG_NAME
-  s.files = %w(README Rakefile setup.rb init.rb) +
+  s.files = %w(README Rakefile init.rb) +
     Dir.glob("{test}/**/*") + 
-    Dir.glob("ext/**/*.{h,cpp,rb,hpp}") +
-    Dir.glob("lib/**/*.rb")
+    Dir.glob("lib/**/*.{rb,cpp,hpp}")
   s.test_files = FileList["{test}/**/*.rb"].to_a
   s.has_rdoc = true
   s.extra_rdoc_files = ["README"]
-  s.rdoc_options = PKG_RDOC_OPTS
-  s.extensions << 'ext/extconf.rb'
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_tar = true
+  pkg.need_tar = false
 end
 
 task :default => [ :test ]
@@ -77,7 +68,6 @@ Rake::RDocTask.new("doc") do |rdoc|
   rdoc.rdoc_files.include('README')
 #  rdoc.rdoc_files.include('CHANGELOG')
 #  rdoc.rdoc_files.include('TODO')
-  rdoc.options = PKG_RDOC_OPTS
   rdoc.rdoc_files.include "ruby-exiv2.cpp"
 end
 
@@ -109,18 +99,4 @@ task :push_docs do
   ].each { |p| p.upload }
 end
 
-desc "Build binary driver"
-task :build do
-  puts `cd lib; [ -e Makefile ] || ruby extconf.rb; make`
-end
-
-desc "Rebuild binary driver"
-task :rebuild do
-  puts `cd lib; ruby extconf.rb; make clean all`
-end
 
-desc "Mark files in SVN"
-task :release => [:clobber, :package] do
-    svn_aware_revision = 'r_' + PKG_VERSION.gsub(/-|\./, '_')
-    puts `svn copy #{PKG_SVN}/trunk #{PKG_SVN}/tags/#{svn_aware_revision} -m "release #{svn_aware_revision}"`
-end

data/{ext → lib}/exiv2.hpp

@@ -89,7 +89,7 @@ void rb_exiv2_throw(const char* file, long unsigned int line, const char *fmt, .
 #if defined(__cplusplus)
 extern "C" {
 #endif
-	void Init_exiv2(void);
+	//void Init_exiv2(void);
 	extern VALUE mExiv2, cImage, cExif, cTag, cIptc, eError;
 
 #if defined(__cplusplus)
@@ -105,9 +105,9 @@ struct rbImage {
 VALUE unmarshall_value(const Exiv2::Value& value);
 
 
-void Init_image();
-void Init_exif();
-void Init_iptc();
+//void Init_image();
+//void Init_exif();
+//void Init_iptc();
 
 
 #endif /* EXIV2_HPP_ */

data/lib/exiv2.rb

@@ -1,38 +1,32 @@
-begin
-  require File.dirname(__FILE__)+'/exiv2_bin'
-rescue LoadError
-  require File.dirname(__FILE__)+'/../ext/exiv2_bin'
-end
 require 'enumerator'
 require 'rubygems'
+require 'inline'
 require 'active_support'
+require 'erb'
 
 module Exiv2
-  #
-  class Image
-    
-    # method [] is used to read exif or iptc data
-    def [](key)
-      return exif[key] if key[0...4] == "Exif"
-      return iptc[key] if key[0...4] == "Iptc"
-    end
-    
-    # method []= is used to set exif or iptc data
-    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
-    
-    # clues together Iptc.Application2.DateCreated and Iptc.Application2.TimeCreated if possible
-    def created_at
-      date = iptc["Iptc.Application2.DateCreated"]
-      time = iptc["Iptc.Application2.TimeCreated"]
-      return date unless time
-      Time.utc(date.year, date.month, date.day, time.hour, time.min, time.sec)
-    end
+  def self.prepare_builder(builder)
+    Config::CONFIG["CPP"] = "g++ -E "
+    Config::CONFIG["CC"] = "g++  "
+    Config::CONFIG["LDSHARED"].gsub!(/^cc /,"g++ ")
+    builder.include "<exiv2.hpp>"
+    builder.add_compile_flags "-x c++ -I#{File.dirname(__FILE__)} -I/usr/local/include/exiv2", '-lstdc++ -lexiv2'
+    builder.include_ruby_last
   end
   
+  def self.load(&block)
+    ERB.new(File.read(File.dirname(__FILE__)+"/exiv2/" + block.call)).result(block.binding)
+  end
+end
+
+require 'exiv2/image'
+require 'exiv2/exif'
+require 'exiv2/iptc'
+require 'exiv2/tag'
+
+module Exiv2
+  class Error < StandardError; end
+  
   class SubTagAccess
     def initialize(class_name, sub_tag, parent)
       @class_name = class_name.split("::").last

data/lib/exiv2/exif.rb

@@ -0,0 +1,19 @@
+module Exiv2
+  class Exif
+    inline do |builder|
+      kind = "Exif"
+      Exiv2::prepare_builder(builder)
+      builder.prefix(Exiv2::load {"metadata/marshall.cpp"})
+      builder.prefix(Exiv2::load {"metadata/unmarshall.cpp"})
+      builder.prefix(Exiv2::load {"throw.cpp"})
+
+      builder.c(Exiv2::load {"metadata/get.cpp"}, {:method_name => "[]"})
+      builder.c(Exiv2::load {"metadata/set.cpp"}, {:method_name => "[]="})
+      builder.c_raw(Exiv2::load {"metadata/each.cpp"}, {:method_name => "each"})
+      builder.c(Exiv2::load {"metadata/delete.cpp"}, {:method_name => "delete"})
+      builder.c(Exiv2::load {"metadata/clear.cpp"}, {:method_name => "clear"})
+      builder.c(Exiv2::load {"metadata/count.cpp"}, {:method_name => "count"})
+      builder.c(Exiv2::load {"metadata/is_empty.cpp"}, {:method_name => "empty?"})
+    end
+  end
+end

data/lib/exiv2/image.rb

@@ -0,0 +1,205 @@
+module Exiv2
+  class Image
+    # method [] is used to read exif or iptc data
+    def [](key)
+      return exif[key] if key[0...4] == "Exif"
+      return iptc[key] if key[0...4] == "Iptc"
+    end
+    
+    # method []= is used to set exif or iptc data
+    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
+    
+    # clues together Iptc.Application2.DateCreated and Iptc.Application2.TimeCreated if possible
+    def created_at
+      date = iptc["Iptc.Application2.DateCreated"]
+      time = iptc["Iptc.Application2.TimeCreated"]
+      return date unless time
+      Time.utc(date.year, date.month, date.day, time.hour, time.min, time.sec)
+    end
+    
+    
+    
+    
+    
+    inline do |builder|
+      Exiv2.prepare_builder(builder)
+      builder.prefix <<-PREFIX
+      VALUE mExiv2, cImage, cExif, cTag, cIptc, cThumbnail, eError;
+      
+
+      static void image_real_save(rbImage* image) {
+      	if(image->dirty) {
+      		image->image->writeMetadata();
+      		image->dirty = false;
+      	}
+      }
+
+      static void image_leave(rbImage* image) {
+      }
+      
+      static void image_delete(rbImage* image) {
+      	__BEGIN
+      	image_real_save(image);
+      	delete image;
+      	__VOID_END
+      }
+      PREFIX
+      
+      builder.c_singleton <<-EOF, :method_name => "new"
+      static VALUE exiv2_image_alloc_and_initialize(VALUE file) {
+      	__BEGIN
+      	rbImage* image = new rbImage();
+      	VALUE rb_image = Data_Wrap_Struct(self, 0, image_delete, image);
+      	image->dirty = false;
+
+
+      	try {
+      		if(!strcmp(rb_class2name(rb_class_of(file)), "StringIO")) {
+      			rb_iv_set(rb_image, "@content", file);
+      			VALUE string = rb_funcall(file, rb_intern("string"), 0);
+      			image->image = Exiv2::ImageFactory::open(CBSTR(string), LEN(string));
+      		} else if(rb_respond_to(file, rb_intern("read"))) {
+      			VALUE file_content = rb_funcall(file, rb_intern("read"), 0);
+      			rb_iv_set(rb_image, "@file_content", file_content);
+      			image->image = Exiv2::ImageFactory::open(CBSTR(file_content), LEN(file_content));
+      		} else if(TYPE(file) == T_STRING) {
+      			image->image = Exiv2::ImageFactory::open(CSTR(file));
+      		}
+      		image->image->readMetadata();
+      	}
+      	catch(const Exiv2::AnyError&) {
+      		rb_raise(eError, "Cannot open file %s", STR(file));
+          }	
+      	return rb_image;
+      	__END
+      }
+      EOF
+      
+      builder.c_singleton <<-EOF, :method_name => "load_string"
+      static VALUE exiv2_image_load_string(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
+      }
+      EOF
+      
+      builder.c <<-EOF, :method_name => "save"
+      static VALUE exiv2_image_save() {
+      	__BEGIN
+      	rbImage* image;
+      	Data_Get_Struct(self, rbImage, image);
+      	image_real_save(image);
+      	return self;
+      	__END
+      }
+      EOF
+      
+      builder.c <<-EOF, :method_name => "clear"
+      static VALUE exiv2_image_clear() {
+      	__BEGIN
+      	rbImage* image;
+      	Data_Get_Struct(self, rbImage, image);
+      	image->image->clearMetadata();
+      	image->dirty = true;
+      	return self;
+      	__END
+      }
+      EOF
+      
+      %w(exif iptc).each do |kind|
+        builder.add_to_init "rb_define_method(c, \"#{kind.classify}\", (VALUE(*)(ANYARGS))exiv2_image_#{kind}, 0);"
+        builder.c <<-EOF, :method_name => kind
+        static VALUE exiv2_image_#{kind}() {
+        	__BEGIN
+        	rbImage* image;
+        	VALUE klass = rb_path2class("Exiv2::#{kind.classify}");
+        	Data_Get_Struct(self, rbImage, image);
+        	VALUE reader = Data_Wrap_Struct(klass, 0, image_leave, image);
+        	rb_iv_set(reader, "@image", self);
+        	return reader;
+        	__END
+        }
+        EOF
+      end
+      
+      builder.c <<-EOF, :method_name => "comment"
+      static VALUE exiv2_image_get_comment() {
+      	__BEGIN
+      	rbImage* image;
+      	Data_Get_Struct(self, rbImage, image);
+      	std::string comment = image->image->comment();
+      	return rb_str_new(comment.c_str(), comment.length());
+      	__END
+      }
+      EOF
+      
+      builder.c <<-EOF, :method_name => "comment="
+      static VALUE exiv2_image_set_comment(VALUE comment) {
+      	__BEGIN
+      	rbImage* image;
+      	Data_Get_Struct(self, rbImage, image);
+      	switch(TYPE(comment)) {
+      		case T_STRING: {
+      			image->image->setComment(CSTR(comment));
+      			image->dirty = true;
+      			break;
+      		}
+      		case T_NIL: {
+      			image->image->clearComment();
+      			image->dirty = true;
+      			break;
+      		}
+      		default: {
+      			rb_raise(rb_eStandardError, "Can only set comment to string, or clear it with nil value");
+      		}
+      	}
+      	return comment;
+      	__END
+      }
+      EOF
+      
+      builder.c <<-EOF, :method_name => "thumbnail"
+      static VALUE exiv2_image_thumbnail(VALUE file_name) {
+      	__BEGIN
+      	Check_Type(file_name, T_STRING);
+
+      	rbImage* image;
+      	Data_Get_Struct(self, rbImage, image);
+
+      	Exiv2::ExifData &exifData = image->image->exifData();
+//      	exifData.writeThumbnail(STR(file_name));
+      	if(rb_block_given_p()) {
+      		rb_yield(file_name);
+      	}
+      	return self;
+      	__END
+      }
+      EOF
+      
+      builder.c <<-EOF, :method_name => "thumbnail="
+      static VALUE exiv2_image_thumbnail_set(VALUE file_name) {
+      	__BEGIN
+      	Check_Type(file_name, T_STRING);
+
+      	rbImage* image;
+      	Data_Get_Struct(self, rbImage, image);
+
+      	Exiv2::ExifData &exifData = image->image->exifData();
+//      	exifData.setJpegThumbnail(STR(file_name));
+      	return self;
+      	__END
+      }
+      EOF
+    end
+  end
+end

data/lib/exiv2/iptc.rb

@@ -0,0 +1,19 @@
+module Exiv2
+  class Iptc
+    inline do |builder|
+      kind = "Iptc"
+      Exiv2::prepare_builder(builder)
+      builder.prefix(Exiv2::load {"metadata/marshall.cpp"})
+      builder.prefix(Exiv2::load {"metadata/unmarshall.cpp"})
+      builder.prefix(Exiv2::load {"throw.cpp"})
+
+      builder.c(Exiv2::load {"metadata/get.cpp"}, {:method_name => "[]"})
+      builder.c(Exiv2::load {"metadata/set.cpp"}, {:method_name => "[]="})
+      builder.c_raw(Exiv2::load {"metadata/each.cpp"}, {:method_name => "each"})
+      builder.c(Exiv2::load {"metadata/delete.cpp"}, {:method_name => "delete"})
+      builder.c(Exiv2::load {"metadata/clear.cpp"}, {:method_name => "clear"})
+      builder.c(Exiv2::load {"metadata/count.cpp"}, {:method_name => "count"})
+      builder.c(Exiv2::load {"metadata/is_empty.cpp"}, {:method_name => "empty?"})
+    end
+  end
+end

data/lib/exiv2/metadata/clear.cpp

@@ -0,0 +1,14 @@
+static VALUE exiv2_metadata_clear() {
+	__BEGIN
+	rbImage* image;
+	Data_Get_Struct(self, rbImage, image);
+
+	Exiv2::<%= kind %>Data &data = image->image-><%= kind.downcase %>Data();
+	
+	if(data.empty()) {
+		return Qnil;
+	}
+	data.clear();
+	return self;
+	__END
+}

data/lib/exiv2/metadata/count.cpp

@@ -0,0 +1,10 @@
+static VALUE exiv2_metadata_count() {
+	__BEGIN
+	rbImage* image;
+	Data_Get_Struct(self, rbImage, image);
+
+	Exiv2::<%= kind %>Data &data = image->image-><%= kind.downcase %>Data();
+	
+	return INT2FIX(data.count());
+	__END
+}

data/lib/exiv2/metadata/delete.cpp

@@ -0,0 +1,23 @@
+static VALUE exiv2_metadata_delete(VALUE rb_key) {
+	__BEGIN
+	rbImage* image;
+	Data_Get_Struct(self, rbImage, image);
+
+	VALUE strkey = rb_funcall(rb_key, rb_intern("to_s"), 0);
+	Exiv2::<%= kind %>Data &data = image->image-><%= kind.downcase %>Data();
+	
+	if(data.empty()) {
+		return Qnil;
+	}
+	
+    Exiv2::<%= kind %>Key key(STR(strkey));
+    Exiv2::<%= kind %>Data::iterator pos = data.findKey(key);
+    if (pos == data.end()) {
+		return Qnil;
+    }
+	
+	std::string v = pos->toString();
+	data.erase(pos);
+	return rb_str_new(v.c_str(), v.length());
+	__NIL_END
+}