libarchive-ruby 0.0.1.dev → 0.0.2

data/README.rdoc

@@ -93,9 +93,21 @@ current directory:
 
   a = Archive.new("myarchive.tar.gz")
   a << "a.rb" << "b.cpp" << "README.rdoc"
-  
+
+If you have more than one file to add you can use an Array:
+
+  a = Archive.new("myarchive.tar.gz")
+  a << ["a.rb", "b.cpp", "README.rdoc"]
+
+You can manipulate the entry witch is added to the file:
+
+  a = Archive.new("myarchive.tar.gz")
+  a.add("a.rb") {|entry| entry.mtime = Time.now }
+
+
   #Note how libarchive-ruby automatically picked up the archive format 
   #you wanted by examining the file extension:
+  a = Archive.new("myarchive.tar.gz")
   puts a.format_name #=> POSIX ustar format
   
 == Further reading

data/ext/archive.cpp

@@ -58,6 +58,16 @@ struct write_obj {
 	std::vector<std::string> *allbuff;
 };
 
+struct add_obj {
+	struct archive* archive;
+	struct archive* file;
+	struct archive_entry* entry;
+	std::vector<struct archive_entry *> *entries;
+	std::vector<std::string> *allbuff;
+	int fd;
+	VALUE obj;
+};
+
 
 VALUE Archive_read_block_ensure(struct archive * data)
 {
@@ -124,6 +134,9 @@ void Archive_format_from_path(VALUE self,int &format,int &compression)
 				compression=ARCHIVE_COMPRESSION_BZIP2;
 			}else if(selfpath.substr(selfpath.length()-4).compare(".tar")==0)
 				format=ARCHIVE_FORMAT_TAR_USTAR;
+		}else{
+			format = _self->format;
+			compression = _self->compression;
 		}
 	}
 	if(format==ARCHIVE_FORMAT_TAR_GNUTAR)
@@ -210,6 +223,7 @@ int Archive_write_set_compression(struct archive *data,int compression)
  *          be guessed from the file extension. Possible formats are: 
  *          * :ar
  *          * :tar
+ *          * :pax
  *          * :xar
  *          * :zip
  * [compression] Symbol inidicating the compression you want to use. If 
@@ -235,6 +249,10 @@ VALUE Archive_initialize(int argc, VALUE *argv,VALUE self)
 		_self->fd = NUM2INT(rb_funcall(path,rb_intern("fileno"),0));
 		_self->type = archive_fd;
 		rb_scan_args(argc, argv, "21", &path,&r_format,&r_compression);
+	}else if(rb_obj_is_kind_of(path,rb_cInteger)){
+		_self->fd = NUM2INT(path);
+		_self->type = archive_fd;
+		rb_scan_args(argc, argv, "21", &path,&r_format,&r_compression);
 	}else if(rb_respond_to(path,rb_intern("read"))){
 		_self->ruby = path;
 		_self->type = archive_ruby;
@@ -260,6 +278,8 @@ VALUE Archive_initialize(int argc, VALUE *argv,VALUE self)
 			rb_raise(rb_eTypeError,"exepted Symbol");
 		if(SYM2ID(r_format) == rb_intern("tar"))
 			format = ARCHIVE_FORMAT_TAR_GNUTAR;
+		else if(SYM2ID(r_format) == rb_intern("pax"))
+			format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
 		else if(SYM2ID(r_format) == rb_intern("zip"))
 			format = ARCHIVE_FORMAT_ZIP;
 		else if(SYM2ID(r_format) == rb_intern("ar"))
@@ -991,10 +1011,169 @@ VALUE Archive_compression_name(VALUE self)
 	return name ? rb_str_new2(name) : Qnil	;
 }
 
+//key is the entry and val is
+
+//TODO: hier nochmal ein ensure rein damit es das file wieder zu macht?
+int Archive_add_hash_block(VALUE key,VALUE val,struct add_obj *obj){
+	char buff[8192];
+	size_t bytes_read;
+	int fd=-1;
+	obj->file = archive_read_disk_new();
+	archive_read_disk_set_standard_lookup(obj->file);
+	struct archive_entry *entry = archive_entry_new();
+	archive_entry_copy_pathname(entry, rb_string_value_cstr(&key));
+	if(rb_obj_is_kind_of(val,rb_cFile)){
+		VALUE pathname = rb_funcall(val,rb_intern("path"),0); //source path
+		VALUE obj2 = rb_file_s_expand_path(1,&pathname);
+		archive_entry_copy_sourcepath(entry, rb_string_value_cstr(&obj2));
+		fd = NUM2INT(rb_funcall(val,rb_intern("fileno"),0));
+	}else if(rb_obj_is_kind_of(val,rb_cIO)){
+		fd = NUM2INT(rb_funcall(val,rb_intern("fileno"),0));
+	}else if(rb_respond_to(val,rb_intern("read"))){
+		//stringio has neigther path or fileno, so do nothing
+	}else {
+		VALUE obj2 = rb_file_s_expand_path(1,&val);
+		archive_entry_copy_sourcepath(entry, rb_string_value_cstr(&obj2));
+		fd = open(rb_string_value_cstr(&obj2), O_RDONLY);
+		if (fd < 0) //TODO: add error
+			return 0;
+	}
+	if(fd > 0)
+		archive_read_disk_entry_from_file(obj->file, entry, fd, NULL);
+	if(rb_block_given_p()){
+		VALUE temp = wrap(entry);
+		VALUE result = rb_yield(temp);
+		if(rb_obj_is_kind_of(result,rb_cArchiveEntry))
+			entry = wrap<archive_entry*>(result);
+		else
+			entry = wrap<archive_entry*>(temp);
+	} 
+	for(unsigned int i = 0;i < obj->entries->size();)
+	{
+		if(std::string(archive_entry_pathname(obj->entries->at(i))).compare(archive_entry_pathname(entry)) != 0){
+			obj->entries->erase(obj->entries->begin()+i);
+			obj->allbuff->erase(obj->allbuff->begin()+i);
+		}else
+			i++;
+	}
+	std::string strbuff;
+	if(fd < 0 and rb_respond_to(val,rb_intern("read"))){
+		VALUE result = rb_funcall(val,rb_intern("read"),0);
+		strbuff.append(rb_string_value_cstr(&result), RSTRING_LEN(result));
+	}else{
+		while ((bytes_read = read(fd, buff, sizeof(buff))) > 0)
+			strbuff.append(buff, bytes_read);
+	}
+	obj->entries->push_back(entry);
+	obj->allbuff->push_back(strbuff);
+	if(fd >= 0 and !rb_obj_is_kind_of(val,rb_cIO))
+		close(fd);
+	archive_read_finish(obj->file);
+	return 0;
+}
+
+VALUE Archive_add_block(struct add_obj *obj )
+{
+	VALUE robj = obj->obj;
+	char buff[8192];
+	size_t bytes_read;
+	archive_read_disk_set_standard_lookup(obj->file);
+	if(rb_obj_is_kind_of(robj,rb_cArray)){
+		for(int i=0;i< RARRAY_LEN(robj);i++){
+			VALUE temp = RARRAY_PTR(robj)[i];
+			int fd = -1;
+			char *sourcepath,*pathname;
+			if(rb_obj_is_kind_of(temp,rb_cFile)){
+				VALUE rpath = rb_funcall(temp,rb_intern("path"),0); //source path
+				pathname = rb_string_value_cstr(&rpath);
+				VALUE obj2 = rb_file_s_expand_path(1,&rpath);
+				sourcepath = rb_string_value_cstr(&obj2);
+				fd = NUM2INT(rb_funcall(temp,rb_intern("fileno"),0));
+			}else{
+				VALUE obj2 = rb_file_s_expand_path(1,&temp);
+				sourcepath = pathname = rb_string_value_cstr(&obj2);
+				fd = open(pathname, O_RDONLY);
+				if (fd < 0) //TODO: add error
+					return Qnil;
+			}
+			struct archive_entry *entry = archive_entry_new();
+			archive_entry_copy_sourcepath(entry, sourcepath);
+			archive_entry_copy_pathname(entry, pathname);
+			archive_read_disk_entry_from_file(obj->file, entry, fd, NULL);
+			if(rb_block_given_p()){
+				VALUE temp = wrap(entry);
+				VALUE result = rb_yield(temp);
+				if(rb_obj_is_kind_of(result,rb_cArchiveEntry))
+					entry = wrap<archive_entry*>(result);
+				else
+					entry = wrap<archive_entry*>(temp);
+			}
+			std::string strbuff;
+			while ((bytes_read = read(fd, buff, sizeof(buff))) > 0)
+				strbuff.append(buff, bytes_read);
+			if(fd >= 0 and !rb_obj_is_kind_of(robj,rb_cIO))
+				close(fd);
+			obj->entries->push_back(entry);
+			obj->allbuff->push_back(strbuff);
+		}
+	}else if(rb_obj_is_kind_of(robj,rb_cHash)){
+		archive_read_finish(obj->file);
+		rb_hash_foreach(robj,(int (*)(...))Archive_add_hash_block,(VALUE)obj);
+	}else {
+		if(obj->fd > 0)
+			archive_read_disk_entry_from_file(obj->file, obj->entry, obj->fd, NULL);
+		if(rb_block_given_p()){
+			VALUE temp = wrap(obj->entry);
+			VALUE result = rb_yield(temp);
+			if(rb_obj_is_kind_of(result,rb_cArchiveEntry))
+				obj->entry = wrap<archive_entry*>(result);
+			else
+				obj->entry = wrap<archive_entry*>(temp);
+		}
+		for(unsigned int i = 0;i < obj->entries->size();)
+		{
+			if(std::string(archive_entry_pathname(obj->entries->at(i))).compare(archive_entry_pathname(obj->entry)) != 0){
+				obj->entries->erase(obj->entries->begin()+i);
+				obj->allbuff->erase(obj->allbuff->begin()+i);
+			}else
+				i++;
+		}
+		std::string strbuff;
+		if(obj->fd < 0 and rb_respond_to(robj,rb_intern("read"))){
+			VALUE result = rb_funcall(robj,rb_intern("read"),0);
+			strbuff.append(rb_string_value_cstr(&result), RSTRING_LEN(result));
+		}else{
+			while ((bytes_read = read(obj->fd, buff, sizeof(buff))) > 0)
+				strbuff.append(buff, bytes_read);
+		}
+		obj->entries->push_back(obj->entry);
+		obj->allbuff->push_back(strbuff);
+	}
+	return Qnil;
+}
+
+VALUE Archive_add_block_ensure(struct add_obj *obj )
+{
+	if(!rb_obj_is_kind_of(obj->obj,rb_cHash))
+		archive_read_finish(obj->file);
+	for(unsigned int i=0; i<obj->entries->size(); i++){
+		archive_write_header(obj->archive,obj->entries->at(i));
+		archive_write_data(obj->archive,obj->allbuff->at(i).c_str(),obj->allbuff->at(i).length());
+		archive_write_finish_entry(obj->archive);
+	}
+	archive_write_finish(obj->archive);
+	return Qnil;
+}
+
 /*
  * call-seq:
- *   add( obj , path ) → self
- * 
+ *   add( obj [, path] ) → self
+ *   add( obj [, path] ) {|entry| } → self
+ *   add( [obj, ... ] ) → self
+ *   add( [obj, ... ] ) {|entry| } → self
+ *   add( { path => obj} ) → self
+ *   add( { path => obj} ) {|entry| } → self
+ *
  * Adds a file to an archive.
  * ===Parameters
  * [obj]  String, IO, File or an object which responds to +read+. 
@@ -1005,13 +1184,27 @@ VALUE Archive_compression_name(VALUE self)
  * [FormatError] Raised if the archive format is not supported for writing. 
 */
 
-VALUE Archive_add(VALUE self,VALUE obj,VALUE name)
+VALUE Archive_add(int argc, VALUE *argv, VALUE self)//(VALUE self,VALUE obj,VALUE name)
 {	
+	VALUE obj,name;
+	rb_scan_args(argc, argv, "11", &obj,&name);
+	if(NIL_P(name)){
+		if(rb_obj_is_kind_of(obj,rb_cFile))
+			name = rb_funcall(name,rb_intern("path"),0);
+		else if(rb_obj_is_kind_of(obj,rb_cIO))
+			rb_scan_args(argc, argv, "20", &obj,&name);
+		else if(rb_respond_to(obj,rb_intern("read")))
+			rb_scan_args(argc, argv, "20", &obj,&name);
+		else if(rb_obj_is_kind_of(obj,rb_cArray) or rb_obj_is_kind_of(obj,rb_cHash))
+			rb_scan_args(argc, argv, "10", &obj);
+		else
+			name = obj;
+	}
 	char buff[8192];
 	char *path = NULL;
 
 	size_t bytes_read;
-	struct archive *a = archive_read_new(),*b=archive_write_new(),*c=archive_read_disk_new();
+	struct archive *a = archive_read_new(),*b=archive_write_new();
 	struct archive_entry *entry;
 	std::vector<struct archive_entry *> entries;
 	std::vector<std::string> allbuff;
@@ -1020,8 +1213,7 @@ VALUE Archive_add(VALUE self,VALUE obj,VALUE name)
 	archive_read_support_format_all(a);
 	archive_read_support_format_raw(a);
 	//autodetect format and compression
-	error=Archive_read_ruby(self,a);
-	if(error==ARCHIVE_OK){
+	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
 		while(archive_read_next_header(a, &entry)==ARCHIVE_OK){
 			entries.push_back(archive_entry_clone(entry));
 			allbuff.push_back(std::string(""));
@@ -1036,14 +1228,14 @@ VALUE Archive_add(VALUE self,VALUE obj,VALUE name)
 		compression = archive_compression(a);
 		archive_read_finish(a);
 	}
-	if(rb_obj_is_kind_of(obj,rb_cIO)){
-		fd = NUM2INT(rb_funcall(obj,rb_intern("fileno"),0));
-	}else if(rb_obj_is_kind_of(obj,rb_cFile)){
+	if(rb_obj_is_kind_of(obj,rb_cFile)){
 		VALUE pathname = rb_funcall(obj,rb_intern("path"),0); //source path
 		VALUE obj2 = rb_file_s_expand_path(1,&pathname);
 		path = rb_string_value_cstr(&obj2);
 		fd = NUM2INT(rb_funcall(obj,rb_intern("fileno"),0));
-	}else if(rb_respond_to(obj,rb_intern("read"))){
+	}else if(rb_obj_is_kind_of(obj,rb_cIO)){
+		fd = NUM2INT(rb_funcall(obj,rb_intern("fileno"),0));
+	}else if(rb_respond_to(obj,rb_intern("read")) or rb_obj_is_kind_of(obj,rb_cArray) or rb_obj_is_kind_of(obj,rb_cHash)){
 		//stringio has neigther path or fileno, so do nothing
 	}else {
 		VALUE obj2 = rb_file_s_expand_path(1,&obj);
@@ -1057,34 +1249,21 @@ VALUE Archive_add(VALUE self,VALUE obj,VALUE name)
 		rb_raise(rb_eArchiveErrorFormat,"error:%d:%s",archive_errno(b),archive_error_string(b));
 	Archive_write_set_compression(b,compression);
 	
-	error=Archive_write_ruby(self,b);
-	if(error==ARCHIVE_OK){	
-		for(unsigned int i=0; i<entries.size(); i++){
-			if(std::string(rb_string_value_cstr(&name)).compare(archive_entry_pathname(entries[i]))!=0){
-				archive_write_header(b,entries[i]);
-				archive_write_data(b,allbuff[i].c_str(),allbuff[i].length());
-				archive_write_finish_entry(b);
-			}
-		}
-		archive_read_disk_set_standard_lookup(c);
+	if(Archive_write_ruby(self,b)==ARCHIVE_OK){
 		entry = archive_entry_new();
 		if (path)
 			archive_entry_copy_sourcepath(entry, path);
-		archive_entry_copy_pathname(entry, rb_string_value_cstr(&name));
-		if(fd < 0 and rb_respond_to(obj,rb_intern("read"))){
-			archive_write_header(b, entry);
-			VALUE result;
-			result = rb_funcall(obj,rb_intern("read"),0);
-			archive_write_data(b, rb_string_value_cstr(&result), RSTRING_LEN(result));
-		}else{
-			archive_read_disk_entry_from_file(c, entry, fd, NULL);
-			archive_write_header(b, entry);
-			while ((bytes_read = read(fd, buff, sizeof(buff))) > 0)
-				archive_write_data(b, buff, bytes_read);
-		}
-		archive_write_finish_entry(b);
-		archive_read_finish(c);
-		archive_write_finish(b);
+		if(!NIL_P(name))
+			archive_entry_copy_pathname(entry, rb_string_value_cstr(&name));
+		add_obj temp;
+		temp.archive = b;
+		temp.file = archive_read_disk_new();
+		temp.entry = entry;
+		temp.fd = fd;
+		temp.obj = obj;
+		temp.entries = &entries;
+		temp.allbuff = &allbuff;
+		RB_ENSURE(Archive_add_block,&temp,Archive_add_block_ensure,&temp);
 	}
 	
 	if(fd >= 0 and !rb_obj_is_kind_of(name,rb_cIO))
@@ -1107,10 +1286,7 @@ VALUE Archive_add(VALUE self,VALUE obj,VALUE name)
 */
 VALUE Archive_add_shift(VALUE self,VALUE name)
 {
-	if(rb_obj_is_kind_of(name,rb_cFile))
-		return Archive_add(self,name,rb_funcall(name,rb_intern("path"),0));
-	else
-		return Archive_add(self,name,name);
+	return Archive_add(1,&name,self);
 }
 
 /*
@@ -1511,7 +1687,7 @@ extern "C" void Init_archive(void){
 	
 	//rb_define_method(rb_cArchive,"move_to",RUBY_METHOD_FUNC(Archive_move_to),1);
 
-	rb_define_method(rb_cArchive,"add",RUBY_METHOD_FUNC(Archive_add),2);
+	rb_define_method(rb_cArchive,"add",RUBY_METHOD_FUNC(Archive_add),-1);
 	rb_define_method(rb_cArchive,"<<",RUBY_METHOD_FUNC(Archive_add_shift),1);
 	
 	rb_define_method(rb_cArchive,"inspect",RUBY_METHOD_FUNC(Archive_inspect),0);

data/ext/entry.cpp

@@ -472,37 +472,66 @@ VALUE ArchiveEntry_inspect(VALUE self){
 
 //ACL added later with acl gem
 
-VALUE ArchiveEntry_acl(VALUE self){
-	archive_entry_acl_reset(_self,ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
-	int type,permset,tag,qual;
-	const char* name;
-	while(archive_entry_acl_next(_self, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,&type, &permset, &tag,&qual, &name) == 0){
-		rb_warn("%i %i %i %s",permset,tag,qual,name);
-	}
+VALUE ArchiveEntry_access_acl(VALUE self){
+	if(rb_const_defined(rb_cObject,rb_intern("ACL"))){
+		VALUE rb_cAcl = rb_const_get(rb_cObject,rb_intern("ACL"));
+		VALUE rb_cAclEntry = rb_const_get(rb_cObject,rb_intern("Entry"));
+		VALUE result = rb_class_new_instance(0,NULL,rb_cAcl);
+		archive_entry_acl_reset(_self,ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
+		int type,permset,tag,qual;
+		const char* name;
+		while(archive_entry_acl_next(_self, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,&type, &permset, &tag,&qual, &name) == 0){
+			VALUE entry;
+			VALUE temp[3];
+			switch(tag){
+			case ARCHIVE_ENTRY_ACL_USER:
+			case ARCHIVE_ENTRY_ACL_USER_OBJ:
+				temp[0] = ID2SYM(rb_intern("user"));
+				break;
+			case ARCHIVE_ENTRY_ACL_GROUP:
+			case ARCHIVE_ENTRY_ACL_GROUP_OBJ:
+				temp[0] = ID2SYM(rb_intern("group"));
+				break;
+			case ARCHIVE_ENTRY_ACL_MASK:
+				temp[0] = ID2SYM(rb_intern("mask"));
+				break;
+			case ARCHIVE_ENTRY_ACL_OTHER:
+				temp[0] = ID2SYM(rb_intern("other"));
+				break;
+			}
+			temp[1] = INT2NUM(permset);
+			switch(tag){
+			case ARCHIVE_ENTRY_ACL_USER:
+			case ARCHIVE_ENTRY_ACL_GROUP:
+				temp[2] = INT2NUM(qual);
+				entry=rb_class_new_instance(3,temp,rb_cAclEntry);
+				break;
+			default:
+				entry=rb_class_new_instance(2,temp,rb_cAclEntry);
+				break;
+			}
+			rb_funcall(result,rb_intern("<<"),1,entry);
+		}
+		return result;
+	}else
+		rb_raise(rb_eNotImpError,"this function require the libacl-ruby gem!");
 	return Qnil;
 }
 
-VALUE ArchiveEntry_access_acl_count(VALUE self){
-	return INT2NUM(archive_entry_acl_count(_self,ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
-}
-
 VALUE ArchiveEntry_acl_add(VALUE self){
 	archive_entry_acl_add_entry(_self,ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ, ARCHIVE_ENTRY_ACL_GROUP,
 	    101, "abc");
 	return self;
 }
 
-/* TODO does not work
+
 VALUE ArchiveEntry_initialize_copy(VALUE self,VALUE source)
 {
-	VALUE result = rb_call_super(1,&source);
-	archive_entry* vself = _self;
-	archive_entry* vsource = archive_entry_clone(wrap<archive_entry*>(source));
-	*vself = *vsource;
-	
-	return result;
+	rarchive_entry  *file;
+  Data_Get_Struct( self, rarchive_entry, file);
+  file->entry = archive_entry_clone(wrap<archive_entry*>(source));
+	return self;
 }
-*/
 
 
 /* Document-attr: atime
@@ -531,7 +560,7 @@ void Init_archive_entry(VALUE rb_cArchive){
 	#endif
 	rb_cArchiveEntry = rb_define_class_under(rb_cArchive,"Entry",rb_cObject);
 	rb_define_alloc_func(rb_cArchiveEntry,ArchiveEntry_alloc);
-	//rb_define_private_method(rb_cArchiveEntry,"initialize_copy",RUBY_METHOD_FUNC(ArchiveEntry_initialize_copy),1);
+	rb_define_private_method(rb_cArchiveEntry,"initialize_copy",RUBY_METHOD_FUNC(ArchiveEntry_initialize_copy),1);
 	rb_define_method(rb_cArchiveEntry,"inspect",RUBY_METHOD_FUNC(ArchiveEntry_inspect),0);
 	
 	rb_define_method(rb_cArchiveEntry,"gname",RUBY_METHOD_FUNC(ArchiveEntry_gname),0);
@@ -581,11 +610,8 @@ void Init_archive_entry(VALUE rb_cArchive){
 	rb_define_method(rb_cArchiveEntry,"<=>",RUBY_METHOD_FUNC(ArchiveEntry_compare),1);
 	
 	rb_define_alias(rb_cArchiveEntry,"to_s","path");
-/*	
-	//rb_define_method(rb_cArchiveEntry,"acl",RUBY_METHOD_FUNC(ArchiveEntry_acl),0);
-	//rb_define_method(rb_cArchiveEntry,"acl_add",RUBY_METHOD_FUNC(ArchiveEntry_acl_add),0);
-		
-	//rb_define_method(rb_cArchiveEntry,"access_acl_count",RUBY_METHOD_FUNC(ArchiveEntry_access_acl_count),0);
+//*	
+	rb_define_method(rb_cArchiveEntry,"access_acl",RUBY_METHOD_FUNC(ArchiveEntry_access_acl),0);
 //*/
 	
 

data/ext/main.hpp

@@ -28,6 +28,7 @@ with libarchive-ruby; if not, write to the Free Software Foundation, Inc.,
 #include <fcntl.h>
 #include <string>
 extern VALUE rb_cArchive,rb_cArchiveEntry;
+
 void Init_archive_entry(VALUE m);
 
 template <typename T>
@@ -50,6 +51,10 @@ struct rarchive{
 	int compression;
 };
 
+struct rarchive_entry{
+	archive_entry *entry;
+};
+
 template <>
 inline VALUE wrap< rarchive >(rarchive *file )
 {
@@ -69,7 +74,10 @@ inline rarchive* wrap< rarchive* >(const VALUE &vfile)
 template <>
 inline VALUE wrap< archive_entry >(struct archive_entry *entry )
 {
-	return Data_Wrap_Struct(rb_cArchiveEntry, NULL, NULL, archive_entry_clone(entry));
+	rarchive_entry *temp = new rarchive_entry;
+	//archive_entry other = archive_entry_clone(entry);
+	temp->entry = archive_entry_clone(entry);
+	return Data_Wrap_Struct(rb_cArchiveEntry, NULL, free, temp);
 }
 
 template <>
@@ -77,9 +85,9 @@ inline archive_entry* wrap< archive_entry* >(const VALUE &vfile)
 {
 	if ( ! rb_obj_is_kind_of(vfile, rb_cArchiveEntry) )
 		return NULL;
-	archive_entry *file;
-  Data_Get_Struct( vfile, archive_entry, file);
-	return file;
+	rarchive_entry  *file;
+  Data_Get_Struct( vfile, rarchive_entry, file);
+	return file->entry;
 }
 
 #endif /* __RubyAchiveMain_H__ */

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: libarchive-ruby
 version: !ruby/object:Gem::Version 
-  prerelease: true
+  prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  - dev
-  version: 0.0.1.dev
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Hanmac
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-12 00:00:00 +01:00
+date: 2011-05-13 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -61,13 +60,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
       segments: 
-      - 1
-      - 3
-      - 1
-      version: 1.3.1
+      - 0
+      version: "0"
 requirements: 
 - A C++ compiler
 - libarchive library