Class: Archive

Inherits:

Object

• Object
• Archive

Includes:

Enumerable

Defined in:

ext/archive.cpp,
ext/entry.cpp,
ext/archive.cpp

Overview

This class represents an archive file. The file may or may not exist, depending on wheather you want to create a new archive or read from an existing one. When instanciating this class, libarchive-ruby will automatically detect the correct file format for you using libarchive’s own detection mechanism if the archive file is already present, otherwise by looking at the archive file’s file extension.

Defined Under Namespace

Classes: Entry, Error

Constant Summary

EXTRACT_OWNER =

extract the owner

INT2NUM(ARCHIVE_EXTRACT_OWNER)

EXTRACT_PERM =

extract the permission

INT2NUM(ARCHIVE_EXTRACT_PERM)

EXTRACT_TIME =

extract the atime and mtime

INT2NUM(ARCHIVE_EXTRACT_TIME)

EXTRACT_NO_OVERWRITE =

INT2NUM(ARCHIVE_EXTRACT_NO_OVERWRITE)

EXTRACT_UNLINK =

INT2NUM(ARCHIVE_EXTRACT_UNLINK)

EXTRACT_ACL =

extract the access control list

INT2NUM(ARCHIVE_EXTRACT_ACL)

EXTRACT_FFLAGS =

extract the fflags

INT2NUM(ARCHIVE_EXTRACT_FFLAGS)

EXTRACT_XATTR =

extract the extended information

INT2NUM(ARCHIVE_EXTRACT_XATTR)

EXTRACT_SECURE_SYMLINKS =

INT2NUM(ARCHIVE_EXTRACT_SECURE_SYMLINKS)

EXTRACT_SECURE_NODOTDOT =

INT2NUM(ARCHIVE_EXTRACT_SECURE_NODOTDOT)

EXTRACT_NO_AUTODIR =

INT2NUM(ARCHIVE_EXTRACT_NO_AUTODIR)

EXTRACT_NO_OVERWRITE_NEWER =

INT2NUM(ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER)

EXTRACT_SPARSE =

INT2NUM(ARCHIVE_EXTRACT_SPARSE)

EXTRACT_MAC_METADATA =

INT2NUM(ARCHIVE_EXTRACT_MAC_METADATA)

Instance Method Summary

• #<<(obj) ⇒ Object

  Adds a file to an archive.

• #[](name) ⇒ Object

  Returns an archive entry for the given name.

• #add ⇒ Object

  (VALUE self,VALUE obj,VALUE name).

• #atime ⇒ Object

  :nodoc: call-seq: archive.atime -> Time.

• #clear ⇒ self

  Deletes all files from an archive.

• #ctime ⇒ Object

  :nodoc: call-seq: archive.ctime -> Time.

• #delete(name) ⇒ Object

  Delete files from an archive.

• #delete_if ⇒ Object

  Yields each entry in the archive to the block and deletes those for which the block evaluates to a truth value.

• #each ⇒ Object

  Iterates through the archive and yields each entry as an Archive::Entry object.

• #each_data ⇒ Object

  Iterates through the archive and yields each entry’s data as a string.

• #each_entry ⇒ Object

  Iterates through the archive and yields each entry as an Archive::Entry object.

• #each_filter ⇒ Object
• #exist? ⇒ Boolean

  :nodoc: call-seq: archive.exist? -> true or false.

• #extract([name = nil [, io [ ,opt ] ] ]) ⇒ Object

  Extract files to current directory.

• #extract_if(*args) ⇒ Object

  Yields each entry in the archive to the block and extracts only those entries (to the current directory) for which the block evaluates to a truth value.

• #format ⇒ Object

  Returns the archive format as an integer.

• #format_name ⇒ Object

  Returns the archive format’s name as a string.

• #new(path[, format [, compression ] ]) ⇒ Object constructor

  Makes a new Archive object.

• #inspect ⇒ String

  Human-readable description.

• #map! ⇒ Object (also: #collect!)

  Iterates through the archive and changes it’s data “on the fly”, i.e.

• #mtime ⇒ Object

  :nodoc: call-seq: archive.mtime -> Time.

• #path ⇒ Object

  Returns the path (filename) of the archive.

• #stat ⇒ Object

  :nodoc: call-seq: archive.stat -> File::Stat.

• #to_hash ⇒ Object

  Iterates through the archive and yields each data of an entry as a string object.

• #unlink ⇒ Object

  :nodoc: call-seq: archive.unlink -> self.

Constructor Details

#new(path[, format [, compression ] ]) ⇒ Object

Makes a new Archive object. If format is given, a new archive is created or

an existing archive will be converted into the given format.
===Parameters
[path]   The path to the archive. May or may not exist.
[format] The archive's format as a symbol. If you ommit this, the format will
         be guessed from the file extension. Possible formats are:
         * :ar
         * :tar
         * :pax
         * :xar
         * :zip
[compression] Symbol inidicating the compression you want to use. If
              ommited, it will be guessed from the file extension.
              Possible formats are:
              * :bzip2
              * :compress
              * :gzip
              * :lzma
              * :xz
===Raises
[FormatError]      Unknown archive format or writing not supported.
[CompressionError] Unknown compression format.
===Examples
See the README for some examples.

# File 'ext/archive.cpp', line 501

VALUE Archive_initialize(int argc, VALUE *argv,VALUE self)
{
	VALUE path,r_format,r_filter;
	rb_scan_args(argc, argv, "12", &path,&r_format,&r_filter);
	if(rb_obj_is_kind_of(path,rb_cIO)){
		_self->fd = NUM2INT(rb_funcall(path,rb_intern("fileno"),0));
		_self->type = archive_fd;
		rb_scan_args(argc, argv, "21", &path,&r_format,&r_filter);
	}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_filter);
	}else if(rb_respond_to(path,rb_intern("read"))){
		_self->type = archive_ruby;
		rb_scan_args(argc, argv, "21", &path,&r_format,&r_filter);
	}else{
		path = rb_file_s_expand_path(1,&path);
		_self->path = std::string(StringValueCStr(path));
		_self->type =archive_path;
	}
	_self->ruby = path;
	//to set the format the file must convert
	if(!NIL_P(r_format)){
	
		//struct archive *a = archive_read_new(),*b=archive_write_new();
		//struct archive_entry *entry;
		int format,filter;
		
		if(SYMBOL_P(r_format)){
			SymToIntType::iterator it = SymToFormat.find(SYM2ID(r_format));
			if(it != SymToFormat.end()) {
				format = it->second;
			}else
				rb_raise(rb_eTypeError,"wrong format");
		}else
			rb_raise(rb_eTypeError,"exepted Symbol");
			
		if(NIL_P(r_filter)){
			filter = ARCHIVE_FILTER_NONE;
		}else if(SYMBOL_P(r_filter)){
			SymToIntType::iterator it = SymToFilter.find(SYM2ID(r_filter));
			if(it != SymToFilter.end()) {
				filter = it->second;
			} else
				rb_raise(rb_eTypeError,"unsupported filter");
		}else
			rb_raise(rb_eTypeError,"exepted Symbol");
		
		//autodetect format and compression

		_self->format = format;
		_self->filter = filter;
		
//		if(Archive_read_ruby(self,a)==ARCHIVE_OK){
//			while(archive_read_next_header(a, &entry)==ARCHIVE_OK){
//				if(format==archive_format(a) && filter==archive_filter_code(a,0)){
//					archive_read_close(a);
//					return self;
//				}
//				entries.push_back(archive_entry_clone(entry));
//				allbuff.push_back(std::string(""));
//				
//				RubyArchive::read_data(a,allbuff.back());
//			}
//			archive_read_close(a);
//			if(Archive_write_ruby(self,b,format,IntVector(filter))==ARCHIVE_OK){
//				//write old data back
//				for(unsigned int i=0; i<entries.size(); i++){
//					archive_write_header(b,entries[i]);
//					archive_write_data(b,allbuff[i].c_str(),allbuff[i].length());
//					archive_write_finish_entry(b);
//				}
//				archive_write_close(b);
//			}
//		}
	}
	return self;
}

Instance Method Details

#<<(obj) ⇒ Object

Adds a file to an archive. Basicly the same as #add, but you can’t set the path inside the archive.

Parameters

obj

String or File

Return value

self

Raises

FormatError

The archive format is not supported for writing.

# File 'ext/archive.cpp', line 1364

VALUE Archive_add_shift(VALUE self,VALUE name)
{
	return Archive_add(1,&name,self);
}

#[](name) ⇒ Object

Returns an archive entry for the given name.

Parameters

name

could be a String or a Regex.

Return value

If a matching entry is found, it’s returned as an Archive::Entry object. If not, nil is returned.

Example

#Assuming your archive contains file.txt and ruby.txt

a["file.txt"] #=> Archive::Entry
a[/txt/] #=> Archive::Entry

# File 'ext/archive.cpp', line 871

VALUE Archive_get(VALUE self,VALUE val)
{
	struct archive *a = archive_read_new();
	struct archive_entry *entry;
	
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
			if(RubyArchive::match_entry(entry,val)){
				VALUE result = wrap(entry);
				archive_read_close(a);
				return result;
			}
		}
		archive_read_close(a);
	}
	return Qnil;
}

#add ⇒ Object

(VALUE self,VALUE obj,VALUE name)

# File 'ext/archive.cpp', line 1280

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;
	}

	struct archive *a = archive_read_new(),*b=archive_write_new();
	
	DataVector entries;
	IntVector filters;
	

	int format= ARCHIVE_FORMAT_EMPTY;

	
	//autodetect format and compression
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		RubyArchive::read_old_data(a, entries, format, filters);
	}
	
//	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 = StringValueCStr(obj2);
//		fd = NUM2INT(rb_funcall(obj,rb_intern("fileno"),0));
//	}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 {
//		if(RTEST(rb_funcall(rb_cFile,rb_intern("directory?"),1,obj)))
//			obj = rb_funcall(rb_cDir,rb_intern("glob"),1,rb_str_new2("**/**/*"));
//		else{
//			VALUE obj2 = rb_file_s_expand_path(1,&obj);
//			path = StringValueCStr(obj2);
//			fd = open(path, O_RDONLY);
//			if (fd < 0) //TODO: add error
//				return self;
//		}
//	}
//	Archive_format_from_path(self,format,compression);
	
	if(format == ARCHIVE_FORMAT_EMPTY){
		Archive_format_from_path(self,format,filters);
	}
	
	if(Archive_write_ruby(self,b,format,filters)==ARCHIVE_OK){
		
		add_obj temp;
		temp.archive = b;
		temp.obj = obj;
		//temp.path = path;
		temp.name = name;
		temp.data = &entries;
		RB_ENSURE(Archive_add_block,&temp,Archive_add_block_ensure,&temp);
	}
	
	return self;
}

#atime ⇒ Object

:nodoc:

call-seq:
archive.atime -> Time

call the File.atime(path)

# File 'ext/archive.cpp', line 1551

VALUE Archive_atime(VALUE self)
{
	return rb_funcall(rb_cFile,rb_intern("atime"),1,Archive_path(self));
}

#clear ⇒ self

Deletes all files from an archive.

Return value

returns self.

Raises

raise Error if the format has no write support

Returns:

• (self)

# File 'ext/archive.cpp', line 1482

VALUE Archive_clear(VALUE self)
{

	struct archive *a = archive_read_new(),*b=archive_write_new();
	struct archive_entry *entry;
	int format = ARCHIVE_FORMAT_EMPTY;
	
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		archive_read_next_header(a, &entry);
		format = archive_format(a);
		IntVector filters;
		RubyArchive::read_get_filters(a,filters);
		archive_read_close(a);
		
		if(Archive_write_ruby(self,b,format,filters)==ARCHIVE_OK)
			archive_write_close(b);
	}
	
	return self;
}

#ctime ⇒ Object

:nodoc:

call-seq:
archive.ctime -> Time

call the File.ctime(path)

# File 'ext/archive.cpp', line 1564

VALUE Archive_ctime(VALUE self)
{
	return rb_funcall(rb_cFile,rb_intern("ctime"),1,Archive_path(self));
}

#delete(name) ⇒ Object

Delete files from an archive.

Parameters

name

An Archive::Entry, a String or a Regex.

Return value

A list of paths removed from the archive.

Raises

raise TypeError if the parameter is neigther String or File. raise Error if the format has no write support

# File 'ext/archive.cpp', line 1383

VALUE Archive_delete(VALUE self,VALUE val)
{
	struct archive *a = archive_read_new(),*b=archive_write_new();
	int format = ARCHIVE_FORMAT_EMPTY;
	
	DataVector entries;
	IntVector filters;
	
	VALUE result = rb_ary_new();
	
	//autodetect format and compression
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		RubyArchive::read_old_data(a, entries, format, filters);

		for(unsigned int i=0; i<entries.size();){
			if(RubyArchive::match_entry(entries[i].first,val)){
				rb_ary_push(result,rb_str_new2(archive_entry_pathname(entries[i].first)));
				entries.erase(entries.begin() + i);
			}else
				++i;
		}

		if(Archive_write_ruby(self,b,format,filters)==ARCHIVE_OK){
			//write old data back
			for(unsigned int i=0; i<entries.size(); i++){
				archive_write_header(b,entries[i].first);
				archive_write_data(b,&entries[i].second[0],entries[i].second.length());
				archive_write_finish_entry(b);
			}
			archive_write_close(b);
		}
		
	}
	return result;
}

#delete_if {|entry| ... } ⇒ self #delete_if ⇒ Enumerator

Yields each entry in the archive to the block and deletes those for which the block evaluates to a truth value.

Parameters

name

An Archive::Entry, a String or a Regex.

Return value

If a block was given, returns self, otherwise an Enumerator.

Raises

raise Error if the format has no write support

Overloads:

• #delete_if {|entry| ... } ⇒ self

  Yields:

  • (entry)

  Returns:

  • (self)
• #delete_if ⇒ Enumerator

  Returns:

  • (Enumerator)

# File 'ext/archive.cpp', line 1448

VALUE Archive_delete_if(VALUE self)
{
	RETURN_ENUMERATOR(self,0,NULL);

	struct archive *a = archive_read_new(),*b=archive_write_new();
	int format = ARCHIVE_FORMAT_EMPTY;
	
	DataVector entries;
	IntVector filters;
	
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		RubyArchive::read_old_data(a, entries, format, filters);
		
		if(Archive_write_ruby(self,b,format,filters)==ARCHIVE_OK){
			write_obj obj;
			obj.archive = b;
			obj.data = &entries;
			return RB_ENSURE(Archive_delete_if_block,&obj,Archive_write_block_ensure,b);
		}	
	}	
	return Qnil;
}

#each ⇒ Object #each ⇒ Object

Iterates through the archive and yields each entry as an Archive::Entry object. The second parameter contains the data of that entry, so you don’t have to extract it only to read what’s in it.

Return value

If a block is given, returns self, otherwise an enumerator.

Example

a.each{|entry| p entry.path}
a.each{|entry, data| puts "'#{entry.path}' contains '#{data}'"}

Output:

"file1.txt"
"file2.txt"
'file1.txt' contains 'I am file1!'
'file2.txt' contains 'I am file2!'

# File 'ext/archive.cpp', line 632

VALUE Archive_each(VALUE self)
{
	RETURN_ENUMERATOR(self,0,NULL);
	struct archive *a = archive_read_new();

	
	int error=Archive_read_ruby(self,a);
	if(error==ARCHIVE_OK){
		RB_ENSURE(Archive_each_block,a,Archive_read_block_ensure,a);
		return self;
	}
	return Qnil;
}

#each_data ⇒ Object #each_data ⇒ Object

Iterates through the archive and yields each entry’s data as a string. This is the same as #each, but doesn’t allow for the first block parameter.

Return value

If a block is given, returns self, otherwise an enumerator.

Example

a.each{|data| puts "This is: '#{data}'"}

Output:

This is: 'I am file1!'
This is: 'I am file2!'

# File 'ext/archive.cpp', line 715

VALUE Archive_each_data(VALUE self)
{
	RETURN_ENUMERATOR(self,0,NULL);
	struct archive *a = archive_read_new();
	
	if(Archive_read_ruby(self,a)==ARCHIVE_OK)
		RB_ENSURE(Archive_each_data_block,a,Archive_read_block_ensure,a);
	return self;
}

#each_entry ⇒ Object #each_entry ⇒ Object

Iterates through the archive and yields each entry as an Archive::Entry object. This is the same as #each, but doesn’t allow for the second block parameter.

Return value

If a block is given, returns an array of Archive::Entry objects, otherwise an enumerator.

Example

a.each_entry{|entry| p entry.path}

Output:

"file1.txt"
"file2.txt"

# File 'ext/archive.cpp', line 676

VALUE Archive_each_entry(VALUE self)
{
	RETURN_ENUMERATOR(self,0,NULL);
	struct archive *a = archive_read_new();
	
	if(Archive_read_ruby(self,a)==ARCHIVE_OK)
		return RB_ENSURE(Archive_each_entry_block,a,Archive_read_block_ensure,a);
	return Qnil;
}

#each_filter ⇒ Object

# File 'ext/archive.cpp', line 737

VALUE Archive_each_filter(VALUE self)
{
	RETURN_ENUMERATOR(self,0,NULL);
	struct archive *a = archive_read_new();
	
	if(Archive_read_ruby(self,a)==ARCHIVE_OK)
		RB_ENSURE(Archive_each_filter_block,a,Archive_read_block_ensure,a);
	return self;
}

#exist? ⇒ Boolean

:nodoc:

call-seq:
  archive.exist? -> true or false

Same as
 File.exist?(archive.path)
. Checks wheather or not the archive file is existant.
===Return value
True or false.

Returns:

• (Boolean)

# File 'ext/archive.cpp', line 1514

VALUE Archive_exist(VALUE self)
{
	return rb_funcall(rb_cFile,rb_intern("exist?"),1,Archive_path(self));
}

#extract([name = nil [, io [ ,opt ] ] ]) ⇒ Object

Extract files to current directory.

Parameters

name

(nil) could be an Archive::Entry, a String or an Regex. If given, only this entry is extracted. Otherwise extracts the whole archive.

io

an instance of IO or something with a write method like StringIO. If given, the entry specified via name will be extracted into io instead of a file.

opt

is an option hash. See below for possible options.

Parameters for the option hash

:extract

flag, Integer combined of the Archive::Extract_* constants. This tells libarchive-ruby to only extract the file attributes you specify here. Exceptions is Archive::EXTRACT_NO_OVERWRITE which prevents this method from overwrtiting existing files.

Return value

The paths of the extracted entries as an array.

Example

#Simply extract everything into the current directory.
a.extract
#Extract only file1.txt
a.extract("file1.txt")
#Same as above, but extract it to a StringIO
s = StringIO.new
a.extract("file1.txt", s)
#Same as the first example, but only extract information about the
#modification time.
a.extract(nil, nil, extract: Archive::EXTRACT_TIME)

# File 'ext/archive.cpp', line 935

VALUE Archive_extract(int argc, VALUE *argv, VALUE self)
{

	VALUE result = rb_ary_new(),name,io,opts,temp;
	struct archive *a = archive_read_new();
	struct archive_entry *entry;
	//add raw, this is not by all
	int extract_opt = 0,fd=-1;
	rb_scan_args(argc, argv, "03", &name,&io,&opts);
	if(rb_obj_is_kind_of(name,rb_cHash)){
		opts = name;name = Qnil;
	}
	if(rb_obj_is_kind_of(io,rb_cHash)){
		opts = io;io = Qnil;
	}
	if(rb_obj_is_kind_of(io,rb_cIO))
		fd = NUM2INT(rb_funcall(io,rb_intern("fileno"),0));
	
	
	if(rb_obj_is_kind_of(opts,rb_cHash))
		if(RTEST(temp=rb_hash_aref(opts,ID2SYM(rb_intern("extract")))))
			extract_opt = NUM2INT(temp);
			
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		try{
			if(NIL_P(name)){
				if(!NIL_P(io)){
					rb_raise(rb_eArgError,"You can't extract more than 1 entry into an IO-like object!");
				}
				while(archive_read_next_header(a, &entry) == ARCHIVE_OK){
					archive_read_extract(a,entry,extract_opt);
					rb_ary_push(result,rb_str_new2(archive_entry_pathname(entry)));
				}
			}else{
				while(archive_read_next_header(a, &entry) == ARCHIVE_OK){
					if(RubyArchive::match_entry(entry,name)){
						extract_extract(a,entry,extract_opt,io,fd);
						rb_ary_push(result,rb_str_new2(archive_entry_pathname(entry)));
					}
				}
			}
		}catch (...){
			rb_raise(rb_eArchiveError,"error:%d:%s",archive_errno(a),archive_error_string(a));
		}
		archive_read_close(a);
	}
	return result;
}

#extract_if([ opt ]) ⇒ Object #extract_if([ opt ]) ⇒ Object

Yields each entry in the archive to the block and extracts only those entries (to the current directory) for which the block evaluates to a truth value.

Parameters

opt

is the same option hash that you can pass to #extract.

Parameters for the option hash

See the #extract method for explanation.

Return value

The paths of all extracted entries if a block was given, an Enumerator otherwise.

# File 'ext/archive.cpp', line 1014

VALUE Archive_extract_if(int argc, VALUE *argv, VALUE self)
{
	RETURN_ENUMERATOR(self,argc,argv);
	VALUE opts,temp;
	struct archive *a = archive_read_new();
	
	int extract_opt=0;
	
	rb_scan_args(argc, argv, "01", &opts);
	if(rb_obj_is_kind_of(opts,rb_cHash))
		if(RTEST(temp=rb_hash_aref(opts,ID2SYM(rb_intern("extract")))))
			extract_opt = NUM2INT(temp);
	
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		extract_obj obj;
		obj.archive = a;
		obj.extract_opt = extract_opt;
		return RB_ENSURE(Archive_extract_if_block,&obj,Archive_read_block_ensure,a);
	}
	return Qnil;
}

#format ⇒ Object

Returns the archive format as an integer. You should use #format_name instead.

Return value

An integer or nil if the format wasn’t detectable.

# File 'ext/archive.cpp', line 1046

VALUE Archive_format(VALUE self)
{
	struct archive *a = archive_read_new();
	struct archive_entry *entry;
	VALUE result = Qnil;
	
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		archive_read_next_header(a, &entry);
		result = INT2NUM(archive_format(a));
		archive_read_close(a);
	}
	return result;
}

#format_name ⇒ Object

Returns the archive format’s name as a string.

Return value

A string or nil if the format wasn’t detectable.

Example

a.format_name #=> "GNU tar format"

# File 'ext/archive.cpp', line 1071

VALUE Archive_format_name(VALUE self)
{
	struct archive *a = archive_read_new();
	struct archive_entry *entry;
	const char* name = NULL;
	
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		if(archive_read_next_header(a, &entry)==ARCHIVE_OK){
			name = archive_format_name(a);
			archive_read_close(a);
		}
	}
	return name ? rb_str_new2(name) : Qnil;
}

#inspect ⇒ String

Human-readable description.

Return value

String

Returns:

• (String)

# File 'ext/archive.cpp', line 1590

VALUE Archive_inspect(VALUE self)
{
	VALUE array[3];
	switch(_self->type){
	case archive_path:
		array[0]=rb_str_new2("#<%s:%s>");
		array[1]=rb_class_of(self);	
		array[2]=Archive_path(self);
		break;
	case archive_fd:
		array[0]=rb_str_new2("#<%s:%d>");
		array[1]=rb_class_of(self);	
		array[2]=INT2NUM(_self->fd);
		break;
	case archive_buffer: 
		break;
	case archive_ruby:
		array[0]=rb_str_new2("#<%s:%s>");
		array[1]=rb_class_of(self);	
		array[2]=_self->ruby;
		break;
	}	
	return rb_f_sprintf(3,array);
}

#map! ⇒ Object #map! ⇒ Object Also known as: collect!

Iterates through the archive and changes it’s data “on the fly”, i.e. the value your block returns for each iteration is put for the data in the yielded entry. Your block is expected to return a 2-element array of form

archive_entry, “data”

where archive_enty is the entry yielded to the block (which you may modify via the Archive::Entry methods) and "data" is a string containing the data you want to set for this entry.

The block parameters are the same as for #each.

Return value

The archive itself.

Example

#Double the contents in each file of the archive
a.map!{|entry, data| [entry, data * 2]}
#Clear all files in the archive
a.map!{|entry| [entry, ""]}

# File 'ext/archive.cpp', line 829

VALUE Archive_map_self(VALUE self)
{
	RETURN_ENUMERATOR(self,0,NULL);

	struct archive *a = archive_read_new(),*b=archive_write_new();
	int format = ARCHIVE_FORMAT_EMPTY;
	
	DataVector entries;
	IntVector filters;
	
	//autodetect format and filters
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		
		RubyArchive::read_old_data(a,entries, format, filters);

		if(Archive_write_ruby(self,b,format,filters)==ARCHIVE_OK){
			write_obj obj;
			obj.archive = b;
			obj.data = &entries;
			RB_ENSURE(Archive_map_block,&obj,Archive_write_block_ensure,b);
		}	
	}	
	return self;
}

#mtime ⇒ Object

:nodoc:

call-seq:
archive.mtime -> Time

call the File.mtime(path)

# File 'ext/archive.cpp', line 1539

VALUE Archive_mtime(VALUE self)
{
	return rb_funcall(rb_cFile,rb_intern("mtime"),1,Archive_path(self));
}

#path ⇒ Object

Returns the path (filename) of the archive.

Return value

Returns path of the archive. May or may not exist.

Example

a.path #=> /home/freak/myarchive.tar.gz

# File 'ext/archive.cpp', line 591

VALUE Archive_path(VALUE self)
{
	return (_self->type == archive_path) ? rb_str_new2(_self->path.c_str()) : Qnil;
}

#stat ⇒ Object

:nodoc:

call-seq:
archive.stat -> File::Stat

call the File.stat(path)

# File 'ext/archive.cpp', line 1576

VALUE Archive_stat(VALUE self)
{
	return rb_funcall(rb_cFile,rb_intern("stat"),1,Archive_path(self));
}

#to_hash ⇒ Object

Iterates through the archive and yields each data of an entry as a string object.

Return value

returns Hash of Archive::Entry => String

# File 'ext/archive.cpp', line 756

VALUE Archive_to_hash(VALUE self)
{
	VALUE result = rb_hash_new();
	struct archive *a = archive_read_new();
	struct archive_entry *entry;
	
	if(Archive_read_ruby(self,a)==ARCHIVE_OK){
		while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
			std::string str;
			RubyArchive::read_data(a,str);
			rb_hash_aset(result,wrap(entry),wrap_data(str));
		}
		archive_read_close(a);
	}
	return result;
}

#unlink ⇒ Object

:nodoc:

call-seq:
archive.unlink -> self

call the File.unlink(path)

# File 'ext/archive.cpp', line 1526

VALUE Archive_unlink(VALUE self)
{
	return rb_funcall(rb_cFile,rb_intern("unlink"),1,Archive_path(self));
	return self;
}