ObjFW  Check-in [0ca94307e6]

/**
 * @brief The last path component of the IRI.
 *
 * Returns the empty string if the path is the root.
 */
@property (readonly, copy, nonatomic) OFString *lastPathComponent;

/**
 * @brief The path extension of the IRI.
 */
@property (readonly, copy, nonatomic) OFString *pathExtension;

/**
 * @brief The query part of the IRI.
 */
@property OF_NULLABLE_PROPERTY (readonly, copy, nonatomic) OFString *query;

/**
 * @brief The query part of the IRI in percent-encoded form.

@property (readonly, nonatomic) OFIRI *IRIByStandardizingPath;

/**
 * @brief The IRI with the last path component deleted.
 */
@property (readonly, nonatomic) OFIRI *IRIByDeletingLastPathComponent;

/**
 * @brief The IRI with the path extension deleted.
 */
@property (readonly, nonatomic) OFIRI *IRIByDeletingPathExtension;

/**
 * @brief The IRI with percent-encoding added for all Unicode characters.
 */
@property (readonly, nonatomic)
    OFIRI *IRIByAddingPercentEncodingForUnicodeCharacters;

#ifdef OF_HAVE_FILES

 *		    instead.
 * @param isDirectory Whether the appended component is a directory, meaning
 *		      that the IRI path should have a trailing slash
 * @return A new IRI with the specified path component appended
 */
- (OFIRI *)IRIByAppendingPathComponent: (OFString *)component
			   isDirectory: (bool)isDirectory;

/**
 * @brief Returns a new IRI with the specified path extension appended.
 *
 * @param extension The path extension to append
 * @return A new IRI with the specified path extension appended.
 */
- (OFIRI *)IRIByAppendingPathExtension: (OFString *)extension;
@end

@interface OFCharacterSet (IRICharacterSets)
#ifdef OF_HAVE_CLASS_PROPERTIES
@property (class, readonly, nonatomic)
    OFCharacterSet *IRISchemeAllowedCharacterSet;
@property (class, readonly, nonatomic)

			  length: length - (lastComponent - UTF8String)];
	ret = [ret.stringByRemovingPercentEncoding retain];

	objc_autoreleasePoolPop(pool);

	return [ret autorelease];
}

- (OFString *)pathExtension
{
	void *pool = objc_autoreleasePoolPush();
	OFString *ret, *fileName;
	size_t pos;

	fileName = self.lastPathComponent;
	pos = [fileName rangeOfString: @"."
			      options: OFStringSearchBackwards].location;
	if (pos == OFNotFound || pos == 0) {
		objc_autoreleasePoolPop(pool);
		return @"";
	}

	ret = [fileName substringFromIndex: pos + 1];

	[ret retain];
	objc_autoreleasePoolPop(pool);
	return [ret autorelease];
}

- (OFString *)query
{
	return _percentEncodedQuery.stringByRemovingPercentEncoding;
}

- (OFString *)percentEncodedQuery

- (OFIRI *)IRIByDeletingLastPathComponent
{
	OFMutableIRI *IRI = [[self mutableCopy] autorelease];
	[IRI deleteLastPathComponent];
	[IRI makeImmutable];
	return IRI;
}

- (OFIRI *)IRIByAppendingPathExtension: (OFString *)extension
{
	OFMutableIRI *IRI = [[self mutableCopy] autorelease];
	[IRI appendPathExtension: extension];
	[IRI makeImmutable];
	return IRI;
}

- (OFIRI *)IRIByDeletingPathExtension
{
	OFMutableIRI *IRI = [[self mutableCopy] autorelease];
	[IRI deletePathExtension];
	[IRI makeImmutable];
	return IRI;
}

- (OFIRI *)IRIByStandardizingPath
{
	OFMutableIRI *IRI = [[self mutableCopy] autorelease];
	[IRI standardizePath];
	[IRI makeImmutable];
	return IRI;

 * @param component The component to append
 * @param isDirectory Whether the path is a directory, in which case a slash is
 *		      appended if there is no slash yet
 */
- (void)appendPathComponent: (OFString *)component
		isDirectory: (bool)isDirectory;

/**
 * @brief Appends the specified path extension
 *
 * @param extension The path extension to append
 */
- (void)appendPathExtension: (OFString *)extension;

/**
 * @brief Deletes the last path component.
 */
- (void)deleteLastPathComponent;

/**
 * @brief Deletes the path extension.
 */
- (void)deletePathExtension;

/**
 * @brief Resolves relative subpaths.
 */
- (void)standardizePath;

/**
 * @brief Converts the mutable IRI to an immutable IRI.
 */
- (void)makeImmutable;
@end

OF_ASSUME_NONNULL_END

	[copy makeImmutable];

	return copy;
}

- (void)appendPathComponent: (OFString *)component
{
	bool isDirectory = false;

#ifdef OF_HAVE_FILES
	if ([_scheme isEqual: @"file"] &&

	    [[OFFileManager defaultManager] directoryExistsAtIRI: self])

		isDirectory = true;
#endif



	[self appendPathComponent: component isDirectory: isDirectory];



}

- (void)appendPathComponent: (OFString *)component
		isDirectory: (bool)isDirectory
{
	void *pool;
	OFString *path;

		path = [path stringByAppendingString: @"/"];

	[_percentEncodedPath release];
	_percentEncodedPath = [path retain];

	objc_autoreleasePoolPop(pool);
}

- (void)appendPathExtension: (OFString *)extension
{
	void *pool;
	OFMutableString *path;
	bool isDirectory = false;

	if (_percentEncodedPath.length == 0)
		return;

	pool = objc_autoreleasePoolPush();
	path = [[_percentEncodedPath mutableCopy] autorelease];

	extension = [extension
	    stringByAddingPercentEncodingWithAllowedCharacters:
	    [OFCharacterSet IRIPathAllowedCharacterSet]];

	if ([path hasSuffix: @"/"]) {
		[path deleteCharactersInRange: OFMakeRange(path.length - 1, 1)];
		isDirectory = true;
	}

	[path appendFormat: @".%@", extension];

	if (isDirectory)
		[path appendString: @"/"];

	[path makeImmutable];
	[_percentEncodedPath release];
	_percentEncodedPath = [path retain];

	objc_autoreleasePoolPop(pool);
}

- (void)deleteLastPathComponent
{
	void *pool = objc_autoreleasePoolPush();
	OFString *path = _percentEncodedPath;
	size_t pos;

	if (path.length == 0 || [path isEqual: @"/"]) {
		objc_autoreleasePoolPop(pool);
		return;
	}

	if ([path hasSuffix: @"/"])
		path = [path substringToIndex: path.length - 1];

	pos = [path rangeOfString: @"/"
			  options: OFStringSearchBackwards].location;
	if (pos == OFNotFound) {
		objc_autoreleasePoolPop(pool);
		return;
	}

	path = [path substringToIndex: pos + 1];
	[_percentEncodedPath release];
	_percentEncodedPath = [path retain];

	objc_autoreleasePoolPop(pool);
}

- (void)deletePathExtension
{
	void *pool = objc_autoreleasePoolPush();
	OFMutableString *path = [[_percentEncodedPath mutableCopy] autorelease];
	bool isDirectory = false;
	size_t pos;

	if ([path hasSuffix: @"/"]) {
		[path deleteCharactersInRange: OFMakeRange(path.length - 1, 1)];
		isDirectory = true;
	}

	pos = [path rangeOfString: @"."
			  options: OFStringSearchBackwards].location;
	if (pos == OFNotFound) {
		objc_autoreleasePoolPop(pool);
		return;
	}

	[path deleteCharactersInRange: OFMakeRange(pos, path.length - pos)];

	if (isDirectory)
		[path appendString: @"/"];

	[path makeImmutable];
	[_percentEncodedPath release];
	_percentEncodedPath = [path retain];

	objc_autoreleasePoolPop(pool);
}

- (void)standardizePath

	OTAssertEqualObjects([[OFIRI IRIWithString: @"http://host/"]
	    lastPathComponent],
	    @"/");

	OTAssertEqualObjects(_IRI[4].lastPathComponent, @"foo/bar");
}

- (void)testPathExtension
{
	OTAssertEqualObjects(
	    [[OFIRI IRIWithString: @"http://host/path.dir/path.file"]
	    pathExtension], @"file");

	OTAssertEqualObjects(
	    [[OFIRI IRIWithString: @"http://host/path/path.dir/"]
	    pathExtension], @"dir");
}

- (void)testQuery
{
	OTAssertEqualObjects(_IRI[0].query, @"que#ry=1&f&oo=b=ar");
	OTAssertNil(_IRI[3].query);
	OTAssertEqualObjects(_IRI[8].query, @"query");
	OTAssertEqualObjects(_IRI[9].query, @"query");

	    [[[OFIRI IRIWithString: @"http://host/"]
	    IRIByDeletingLastPathComponent] path], @"/");

	OTAssertEqualObjects(
	    [[[OFIRI IRIWithString: @"http://host"]
	    IRIByDeletingLastPathComponent] path], @"");
}

- (void)testIRIByAppendingPathExtension
{
	OTAssertEqualObjects(
	    [[[OFIRI IRIWithString: @"http://host/path.dir/path"]
	    IRIByAppendingPathExtension: @"file"] path],
	    @"/path.dir/path.file");

	OTAssertEqualObjects(
	    [[[OFIRI IRIWithString: @"http://host/path/path/"]
	    IRIByAppendingPathExtension: @"dir"] path],
	    @"/path/path.dir/");
}

- (void)testIRIByDeletingPathExtension
{
	OTAssertEqualObjects(
	    [[[OFIRI IRIWithString: @"http://host/path.dir/path.file"]
	    IRIByDeletingPathExtension] path],
	    @"/path.dir/path");

	OTAssertEqualObjects(
	    [[[OFIRI IRIWithString: @"http://host/path/path.dir/"]
	    IRIByDeletingPathExtension] path],
	    @"/path/path/");
}

- (void)testIRIByAddingPercentEncodingForUnicodeCharacters
{
	OTAssertEqualObjects(
	    _IRI[10].IRIByAddingPercentEncodingForUnicodeCharacters,
	    [OFIRI IRIWithString: @"http://%C3%A4/%C3%B6?%C3%BC"]);
}

		[OFStdErr writeLine: OF_LOCALIZED(
		    @"cannot_extract_specific_file_from_gz",
		    @"Cannot extract a specific file of a .gz archive!")];
		app->_exitStatus = 1;
		return;
	}


	fileName = _archiveIRI.IRIByDeletingPathExtension.lastPathComponent;

	if (app->_outputLevel >= 0)
		[OFStdOut writeString: OF_LOCALIZED(@"extracting_file",
		    @"Extracting %[file]...",
		    @"file", fileName)];

	if (![app shouldExtractFile: fileName outFileName: fileName])

		    @"Extracting %[file]... done",
		    @"file", fileName)];
	}
}

- (void)printFiles: (OFArray OF_GENERIC(OFString *) *)files
{

	OFString *fileName =
	    _archiveIRI.IRIByDeletingPathExtension.lastPathComponent;

	if (files.count > 0) {
		[OFStdErr writeLine: OF_LOCALIZED(
		    @"cannot_print_specific_file_from_gz",
		    @"Cannot print a specific file of a .gz archive!")];
		app->_exitStatus = 1;
		return;

	if (partNumber > 98)
		return nil;

	if (partNumber == lastPartNumber)
		IRI = _archiveIRI;
	else {
		OFMutableIRI *copy = [[_archiveIRI mutableCopy] autorelease];
		[copy deletePathExtension];
		[copy appendPathExtension: [OFString
		    stringWithFormat: @".z%02u", partNumber + 1]];
		[copy makeImmutable];
		IRI = copy;
	}

	return (OFSeekableStream *)[OFIRIHandler openItemAtIRI: IRI mode: @"r"];
}