libalpm: add iterator interface for syncdb files

This commit adds an iterator interface for reading files from the
syncdbs. Instead of using alpm_pkg_get_files(), you now get the files
from the database using alpm_db_files_open(), you then use
alpm_db_files_next() to iterate through the files for each package. If
you want to actually load the files from that package you then use
alpm_db_files_load().

This means alpm_pkg_get_files() will always return empty for syncdbs,
even on .files databases, however these functions still work on the
localdb and loaded packages.

This aproach is faster when dumping the entire file list but slower when
searching for a specific package.

The memory usage of pacman is drastically less. See below.

build/pacman -Fl        0.55s user 0.01s system 99% cpu 0.556 total
build/pacman -Fl pacman 0.46s user 0.01s system 99% cpu 0.472 total
build/pacman -Fx pacman 2.88s user 0.09s system 99% cpu 2.965 total

pacman -Fl              1.60s user 0.13s system 99% cpu 1.731 total
pacman -Fl pacman       0.24s user 0.04s system 99% cpu 0.283 total
pacman -Fx pacman       2.45s user 0.14s system 99% cpu 2.593 total

                         Peak Memory
build/pacman -Fl         43.52MB
build/pacman -Fl pacmam  11.292MB

pacman -Fl               677.048MB
pacman -Fl pacman        163.288MB

doc/pacman.8.asciidoc

@@ -256,12 +256,6 @@ Upgrade Options (apply to '-S' and '-U')[[UO]]
 	as explicitly installed so it will not be removed by the '\--recursive'
 	remove operation.
 
-*\--note*::
-	Add an install note to packages. This will only apply to targets explicitly
-	listed and not their dependencies. The note can be used to keep track of why
-	a package was installed or any other info of note. The note can later be
-	edited or removed with '\--D \--note' or '\--D \--rmnote' respectively.
-
 *\--ignore* <package>::
 	Directs pacman to ignore upgrades of package even if there is one
 	available. Multiple packages can be specified by separating them
@@ -474,13 +468,6 @@ Database Options (apply to '-D')[[QO]]
 	package installed even when it was initially installed as a dependency
 	of another package.
 
-*\--note*::
-	Add or edit a package's install note. The note can be used to keep track of why
-	a package was installed or any other info of note.
-
-*\--rmnote*::
-	Remove a package's install note.
-
 *-k, \--check*::
 	Check the local package database is internally consistent. This will
 	check all required files are present and that installed packages have

lib/libalpm/add.c

@@ -431,22 +431,8 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 
 	ASSERT(trans != NULL, return -1);
 
-
-	if(_alpm_db_get_pkgfromcache(db, newpkg->name)) {
-			oldpkg = newpkg->oldpkg;
-	}
-
-	/* set note on package only if it was explicitly added to transaction */
-	if(trans->note && newpkg->reason == ALPM_PKG_REASON_EXPLICIT) {
-		STRDUP(newpkg->note, trans->note,
-				RET_ERR(handle, ALPM_ERR_MEMORY, -1));
-	} else if(oldpkg && oldpkg->note) {
-		STRDUP(newpkg->note,oldpkg->note,
-				RET_ERR(handle, ALPM_ERR_MEMORY, -1));
-	}
-
-	if(oldpkg) {
 	/* see if this is an upgrade. if so, remove the old package first */
+	if(_alpm_db_get_pkgfromcache(db, newpkg->name) && (oldpkg = newpkg->oldpkg)) {
 		int cmp = _alpm_pkg_compare_versions(newpkg, oldpkg);
 		if(cmp < 0) {
 			log_msg = "downgrading";

lib/libalpm/alpm.h

@@ -101,6 +101,11 @@ typedef struct _alpm_handle_t alpm_handle_t;
 typedef struct _alpm_db_t alpm_db_t;
 
 
+/** A Database file iterator
+ * @ingroup libalpm_databases
+ */
+typedef struct __alpm_db_files_t alpm_db_files_t;
+
 /** A package.
  *
  * A package can be loaded from disk via \link alpm_pkg_load \endlink or retrieved from a database.
@@ -158,6 +163,9 @@ typedef struct _alpm_backup_t {
  */
 alpm_file_t *alpm_filelist_contains(alpm_filelist_t *filelist, const char *path);
 
+/** Frees a file list */
+void  alpm_filelist_free(alpm_filelist_t *files);
+
 /* End of libalpm_files */
 /** @} */
 
@@ -1444,6 +1452,42 @@ int alpm_db_get_usage(alpm_db_t *db, int *usage);
 /* End of usage accessors */
 /** @} */
 
+/** @name File iterators
+ * @{
+ */
+
+/** Opens a handle to the db files iterator.
+ * @param db the db files to iterate over
+ * @return handle to the iterator
+ */
+alpm_db_files_t *alpm_db_files_open(alpm_db_t *db);
+
+/** Goes to the next package.
+ * @param files handle to the file iterator
+ * @param pkgname stores the pkgname of the current package
+ * @return 0 on success, 1 if end of iterator, -1 on error
+ */
+int alpm_db_files_next(alpm_db_files_t *files, char** pkgname);
+
+/** Loads the files for a package into a file list.
+ *
+ * This extends the file list as needed, reusing the memory alloced.
+ * You can reuse the same file list for calls to this function but
+ * the list should be freed with \link alpm_filelist_free alpm_filelist_free \endlink
+ * after use.
+ * @param files handle to the file iterator
+ * @param filelist the filelist to load files into
+ * @return 0 on success, -1 on error
+ */
+int alpm_db_files_load(alpm_db_files_t *files, alpm_filelist_t *filelist);
+
+/** Close the db file iterator
+ * @param files handle to the file iterator
+ */
+void alpm_db_files_close(alpm_db_files_t *files);
+
+/* End of file iterators */
+/** @} */
 
 /* End of libalpm_databases */
 /** @} */
@@ -2429,12 +2473,6 @@ const char *alpm_pkg_get_desc(alpm_pkg_t *pkg);
  */
 const char *alpm_pkg_get_url(alpm_pkg_t *pkg);
 
-/** Returns the package note.
- * @param pkg a pointer to package
- * @return a reference to an internal string
- */
-char *alpm_pkg_get_note(alpm_pkg_t *pkg);
-
 /** Returns the build timestamp of the package.
  * @param pkg a pointer to package
  * @return the timestamp of the build time
@@ -2613,15 +2651,6 @@ off_t alpm_pkg_download_size(alpm_pkg_t *newpkg);
  */
 int alpm_pkg_set_reason(alpm_pkg_t *pkg, alpm_pkgreason_t reason);
 
-/** Set install note for a package in the local database.
- * The provided package object must be from the local database or this method
- * will fail. The write to the local database is performed immediately.
- * @param pkg the package to edit
- * @param note the new install note, null to remove a note
- * @return 0 on success, -1 on error (pm_errno is set accordingly)
- */
-int alpm_pkg_set_note(alpm_pkg_t *pkg, char *note);
-
 
 /* End of libalpm_pkg_t accessors */
 /** @} */
@@ -2693,7 +2722,6 @@ int alpm_pkg_mtree_close(const alpm_pkg_t *pkg, struct archive *archive);
 /* End of mtree accessors */
 /** @} */
 
-
 /* End of libalpm_packages */
 /** @} */
 
@@ -2771,16 +2799,6 @@ alpm_list_t *alpm_trans_get_add(alpm_handle_t *handle);
  */
 alpm_list_t *alpm_trans_get_remove(alpm_handle_t *handle);
 
-/** Sets the install note for a transaction
- *
- * All target packages will gain the note, dependencies will not.
- *
- * @param handle the context handle
- * @note the the note, may not contain new lines
- * @return 0 on success, -1 on error (pm_errno is set accordingly)
- */
-int alpm_trans_set_note(alpm_handle_t *handle, char *note);
-
 /** Initialize the transaction.
  * @param handle the context handle
  * @param flags flags of the transaction (like nodeps, etc; see alpm_transflag_t)

lib/libalpm/be_local.c

@@ -81,12 +81,6 @@ static const char *_cache_get_url(alpm_pkg_t *pkg)
 	return pkg->url;
 }
 
-static char *_cache_get_note(alpm_pkg_t *pkg)
-{
-	LAZY_LOAD(INFRQ_DESC);
-	return pkg->note;
-}
-
 static alpm_time_t _cache_get_builddate(alpm_pkg_t *pkg)
 {
 	LAZY_LOAD(INFRQ_DESC);
@@ -336,7 +330,6 @@ static const struct pkg_operations local_pkg_ops = {
 	.get_base = _cache_get_base,
 	.get_desc = _cache_get_desc,
 	.get_url = _cache_get_url,
-	.get_note = _cache_get_note,
 	.get_builddate = _cache_get_builddate,
 	.get_installdate = _cache_get_installdate,
 	.get_packager = _cache_get_packager,
@@ -759,8 +752,6 @@ static int local_db_read(alpm_pkg_t *info, int inforeq)
 				READ_AND_STORE_ALL(info->groups);
 			} else if(strcmp(line, "%URL%") == 0) {
 				READ_AND_STORE(info->url);
-			} else if(strcmp(line, "%NOTE%") == 0) {
-				READ_AND_STORE(info->note);
 			} else if(strcmp(line, "%LICENSE%") == 0) {
 				READ_AND_STORE_ALL(info->licenses);
 			} else if(strcmp(line, "%ARCH%") == 0) {
@@ -1049,11 +1040,6 @@ int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, int inforeq)
 		write_deps(fp, "%CONFLICTS%", info->conflicts);
 		write_deps(fp, "%PROVIDES%", info->provides);
 
-		if(info->note) {
-			fprintf(fp, "%%NOTE%%\n"
-							"%s\n\n", info->note);
-		}
-
 		fclose(fp);
 		fp = NULL;
 	}
@@ -1172,31 +1158,6 @@ int SYMEXPORT alpm_pkg_set_reason(alpm_pkg_t *pkg, alpm_pkgreason_t reason)
 	return 0;
 }
 
-int SYMEXPORT alpm_pkg_set_note(alpm_pkg_t *pkg, char *note)
-{
-	ASSERT(pkg != NULL, return -1);
-	ASSERT(pkg->origin == ALPM_PKG_FROM_LOCALDB,
-			RET_ERR(pkg->handle, ALPM_ERR_WRONG_ARGS, -1));
-	ASSERT(pkg->origin_data.db == pkg->handle->db_local,
-			RET_ERR(pkg->handle, ALPM_ERR_WRONG_ARGS, -1));
-
-	_alpm_log(pkg->handle, ALPM_LOG_DEBUG,
-			"setting note for %s: %s\n", pkg->name, note);
-	LAZY_LOAD(INFRQ_DESC);
-	FREE(pkg->note);
-	if(note) {
-		ASSERT(!strchr(note, '\n'), RET_ERR(pkg->handle, ALPM_ERR_WRONG_ARGS, -1));
-		STRDUP(pkg->note, note,
-				RET_ERR(pkg->handle, ALPM_ERR_MEMORY, -1));
-	}
-	/* write DESC */
-	if(_alpm_local_db_write(pkg->handle->db_local, pkg, INFRQ_DESC)) {
-		RET_ERR(pkg->handle, ALPM_ERR_DB_WRITE, -1);
-	}
-
-	return 0;
-}
-
 static const struct db_operations local_db_ops = {
 	.validate         = local_db_validate,
 	.populate         = local_db_populate,

lib/libalpm/be_sync.c

@@ -566,8 +566,7 @@ static int sync_db_read(alpm_db_t *db, struct archive *archive,
 		return 0;
 	}
 
-	if(strcmp(filename, "desc") == 0 || strcmp(filename, "depends") == 0
-			|| strcmp(filename, "files") == 0) {
+	if(strcmp(filename, "desc") == 0 || strcmp(filename, "depends") == 0) {
 		int ret;
 		while((ret = _alpm_archive_fgets(archive, &buf)) == ARCHIVE_OK) {
 			char *line = buf.line;
@@ -636,36 +635,6 @@ static int sync_db_read(alpm_db_t *db, struct archive *archive,
 				READ_AND_SPLITDEP(pkg->conflicts);
 			} else if(strcmp(line, "%PROVIDES%") == 0) {
 				READ_AND_SPLITDEP(pkg->provides);
-			} else if(strcmp(line, "%FILES%") == 0) {
-				/* TODO: this could lazy load if there is future demand */
-				size_t files_count = 0, files_size = 0;
-				alpm_file_t *files = NULL;
-
-				while(1) {
-					if(_alpm_archive_fgets(archive, &buf) != ARCHIVE_OK) {
-						goto error;
-					}
-					line = buf.line;
-					if(_alpm_strip_newline(line, buf.real_line_size) == 0) {
-						break;
-					}
-
-					if(!_alpm_greedy_grow((void **)&files, &files_size,
-								(files_count ? (files_count + 1) * sizeof(alpm_file_t) : 8 * sizeof(alpm_file_t)))) {
-						goto error;
-					}
-					STRDUP(files[files_count].name, line, goto error);
-					files_count++;
-				}
-				/* attempt to hand back any memory we don't need */
-				if(files_count > 0) {
-					REALLOC(files, sizeof(alpm_file_t) * files_count, (void)0);
-				} else {
-					FREE(files);
-				}
-				pkg->files.count = files_count;
-				pkg->files.files = files;
-				_alpm_filelist_sort(&pkg->files);
 			}
 		}
 		if(ret != ARCHIVE_EOF) {
@@ -716,3 +685,152 @@ alpm_db_t *_alpm_db_register_sync(alpm_handle_t *handle, const char *treename,
 	handle->dbs_sync = alpm_list_add(handle->dbs_sync, db);
 	return db;
 }
+
+static int load_files(struct archive *archive, alpm_filelist_t *filelist)
+{
+	struct archive_read_buffer buf = {0};
+
+	/* 512K for a line length seems reasonable */
+	buf.max_line_size = 512 * 1024;
+
+	_alpm_filelist_truncate(filelist);
+
+	int ret;
+	while((ret = _alpm_archive_fgets(archive, &buf)) == ARCHIVE_OK) {
+		char *line = buf.line;
+		if(_alpm_strip_newline(line, buf.real_line_size) == 0) {
+			/* length of stripped line was zero */
+			continue;
+		}
+
+		if(strcmp(line, "%FILES%") == 0) {
+			size_t files_size = 0;
+
+			while(1) {
+				if(_alpm_archive_fgets(archive, &buf) != ARCHIVE_OK) {
+					goto error;
+				}
+				line = buf.line;
+				if(_alpm_strip_newline(line, buf.real_line_size) == 0) {
+					break;
+				}
+
+				if(!_alpm_greedy_grow((void **)&filelist->files, &files_size,
+							(filelist->count ? (filelist->count + 1) * sizeof(alpm_file_t) : 8 * sizeof(alpm_file_t)))) {
+					goto error;
+				}
+				STRDUP(filelist->files[filelist->count].name, line, goto error);
+				filelist->count++;
+			}
+			_alpm_filelist_sort(filelist);
+		}
+	}
+	if(ret != ARCHIVE_EOF) {
+		goto error;
+	}
+
+	return 0;
+
+error:
+	return -1;
+}
+
+alpm_db_files_t SYMEXPORT *alpm_db_files_open(alpm_db_t *db)
+{
+	const char *dbpath;
+	int fd;
+	struct stat buf;
+	struct archive *archive;
+	alpm_db_files_t *files = NULL;
+
+	ASSERT(db != NULL, return NULL);
+
+	dbpath = _alpm_db_path(db);
+	if(!dbpath) {
+		/* pm_errno set in _alpm_db_path() */
+		return NULL;
+	}
+
+	if(db->status & DB_STATUS_INVALID || db->status & DB_STATUS_MISSING) {
+		return NULL;
+	}
+
+	fd = _alpm_open_archive(db->handle, dbpath, &buf,
+			&archive, ALPM_ERR_DB_OPEN);
+	if(fd < 0) {
+		db->status &= ~DB_STATUS_VALID;
+		db->status |= DB_STATUS_INVALID;
+		_alpm_archive_read_free(archive);
+		return NULL;
+	}
+
+	MALLOC(files, sizeof(alpm_db_files_t), RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL));
+	files->archive = archive;
+	files->fd = fd;
+	files->db = db;
+	return files;
+}
+
+int SYMEXPORT alpm_db_files_next(alpm_db_files_t *files, char** pkgname)
+{
+	struct archive_entry *entry;
+	const char *entryname;
+	int archive_ret;
+	char *filename;
+
+	ASSERT(files != NULL, return -1);
+	ASSERT(pkgname != NULL, return -1);
+
+	while((archive_ret = archive_read_next_header(files->archive, &entry)) == ARCHIVE_OK) {
+		mode_t mode = archive_entry_mode(entry);
+		if(!S_ISDIR(mode)) {
+			entryname = archive_entry_pathname(entry);
+			if(entryname == NULL) {
+				_alpm_log(files->db->handle, ALPM_LOG_DEBUG,
+						"invalid archive entry provided to alpm_db_files_next, skipping\n");
+				return -1;
+			}
+
+			if(_alpm_splitname(entryname, pkgname, NULL, NULL) != 0) {
+				_alpm_log(files->db->handle, ALPM_LOG_ERROR,
+						_("invalid name for database entry '%s'\n"), entryname);
+				return -1;
+			}
+
+			filename = strrchr(entryname, '/');
+			filename++;
+
+			/* we only want to read the file list */
+			if(filename && strcmp(filename, "files") == 0) {
+				return 0;
+			}
+		}
+	}
+	if(archive_ret != ARCHIVE_EOF) {
+		return -1;
+	}
+	return 1;
+}
+
+int SYMEXPORT alpm_db_files_load(alpm_db_files_t *files, alpm_filelist_t *filelist)
+{
+	ASSERT(files != NULL, return -1);
+	ASSERT(filelist != NULL, return -1);
+
+	_alpm_filelist_truncate(filelist);
+	if(load_files(files->archive, filelist) != 0) {
+		_alpm_log(files->db->handle, ALPM_LOG_ERROR,
+			_("could not parse package description file '%s' from db '%s'\n"),
+			"files", files->db->treename);
+		return -1;
+	}
+	return 0;
+}
+
+void SYMEXPORT alpm_db_files_close(alpm_db_files_t *files)
+{
+	ASSERT(files != NULL, return);
+	_alpm_archive_read_free(files->archive);
+	close(files->fd);
+	free(files);
+}

lib/libalpm/db.c

@@ -405,7 +405,6 @@ int _alpm_db_search(alpm_db_t *db, const alpm_list_t *needles,
 			const char *matched = NULL;
 			const char *name = pkg->name;
 			const char *desc = alpm_pkg_get_desc(pkg);
-			const char *note = alpm_pkg_get_note(pkg);
 
 			/* check name as regex AND as plain text */
 			if(name && (regexec(&reg, name, 0, 0, 0) == 0 || strstr(name, targ))) {
@@ -415,11 +414,6 @@ int _alpm_db_search(alpm_db_t *db, const alpm_list_t *needles,
 			else if(desc && regexec(&reg, desc, 0, 0, 0) == 0) {
 				matched = desc;
 			}
-			/* check note */
-			else if(note && regexec(&reg, note, 0, 0, 0) == 0) {
-				matched = note;
-			}
-
 			/* TODO: should we be doing this, and should we print something
 			 * differently when we do match it since it isn't currently printed? */
 			if(!matched) {

lib/libalpm/db.h

@@ -61,6 +61,13 @@ struct db_operations {
 	void (*unregister) (alpm_db_t *);
 };
 
+/* Database files iterator */
+struct __alpm_db_files_t {
+	struct archive *archive;
+	int fd;
+	alpm_db_t *db;
+};
+
 /* Database */
 struct _alpm_db_t {
 	alpm_handle_t *handle;

lib/libalpm/filelist.c

@@ -145,3 +145,17 @@ void _alpm_filelist_sort(alpm_filelist_t *filelist)
 		}
 	}
 }
+
+void _alpm_filelist_truncate(alpm_filelist_t *files)
+{
+	for(size_t i = 0; i < files->count; i++) {
+		FREE(files->files[i].name);
+	}
+	files->count = 0;
+}
+
+void SYMEXPORT alpm_filelist_free(alpm_filelist_t *files)
+{
+	_alpm_filelist_truncate(files);
+	free(files->files);
+}

lib/libalpm/filelist.h

@@ -28,5 +28,6 @@ alpm_list_t *_alpm_filelist_intersection(alpm_filelist_t *filesA,
 		alpm_filelist_t *filesB);
 
 void _alpm_filelist_sort(alpm_filelist_t *filelist);
+void _alpm_filelist_truncate(alpm_filelist_t *filelist);
 
 #endif /* ALPM_FILELIST_H */

lib/libalpm/package.c

@@ -78,7 +78,6 @@ int SYMEXPORT alpm_pkg_checkmd5sum(alpm_pkg_t *pkg)
 static const char *_pkg_get_base(alpm_pkg_t *pkg)        { return pkg->base; }
 static const char *_pkg_get_desc(alpm_pkg_t *pkg)        { return pkg->desc; }
 static const char *_pkg_get_url(alpm_pkg_t *pkg)         { return pkg->url; }
-static char *_pkg_get_note(alpm_pkg_t *pkg)        { return pkg->note; }
 static alpm_time_t _pkg_get_builddate(alpm_pkg_t *pkg)   { return pkg->builddate; }
 static alpm_time_t _pkg_get_installdate(alpm_pkg_t *pkg) { return pkg->installdate; }
 static const char *_pkg_get_packager(alpm_pkg_t *pkg)    { return pkg->packager; }
@@ -100,6 +99,7 @@ static alpm_list_t *_pkg_get_replaces(alpm_pkg_t *pkg)   { return pkg->replaces;
 static alpm_filelist_t *_pkg_get_files(alpm_pkg_t *pkg)  { return &(pkg->files); }
 static alpm_list_t *_pkg_get_backup(alpm_pkg_t *pkg)     { return pkg->backup; }
 
+
 static void *_pkg_changelog_open(alpm_pkg_t UNUSED *pkg)
 {
 	return NULL;
@@ -143,7 +143,6 @@ const struct pkg_operations default_pkg_ops = {
 	.get_base        = _pkg_get_base,
 	.get_desc        = _pkg_get_desc,
 	.get_url         = _pkg_get_url,
-	.get_note        = _pkg_get_note,
 	.get_builddate   = _pkg_get_builddate,
 	.get_installdate = _pkg_get_installdate,
 	.get_packager    = _pkg_get_packager,
@@ -228,13 +227,6 @@ const char SYMEXPORT *alpm_pkg_get_url(alpm_pkg_t *pkg)
 	return pkg->ops->get_url(pkg);
 }
 
-char SYMEXPORT *alpm_pkg_get_note(alpm_pkg_t *pkg)
-{
-	ASSERT(pkg != NULL, return NULL);
-	pkg->handle->pm_errno = ALPM_ERR_OK;
-	return pkg->ops->get_note(pkg);
-}
-
 alpm_time_t SYMEXPORT alpm_pkg_get_builddate(alpm_pkg_t *pkg)
 {
 	ASSERT(pkg != NULL, return -1);
@@ -619,7 +611,6 @@ int _alpm_pkg_dup(alpm_pkg_t *pkg, alpm_pkg_t **new_ptr)
 	STRDUP(newpkg->version, pkg->version, goto cleanup);
 	STRDUP(newpkg->desc, pkg->desc, goto cleanup);
 	STRDUP(newpkg->url, pkg->url, goto cleanup);
-	STRDUP(newpkg->note, pkg->note, goto cleanup);
 	newpkg->builddate = pkg->builddate;
 	newpkg->installdate = pkg->installdate;
 	STRDUP(newpkg->packager, pkg->packager, goto cleanup);
@@ -693,7 +684,6 @@ void _alpm_pkg_free(alpm_pkg_t *pkg)
 	FREE(pkg->version);
 	FREE(pkg->desc);
 	FREE(pkg->url);
-	FREE(pkg->note);
 	FREE(pkg->packager);
 	FREE(pkg->md5sum);
 	FREE(pkg->sha256sum);

lib/libalpm/package.h

@@ -46,7 +46,6 @@ struct pkg_operations {
 	const char *(*get_base) (alpm_pkg_t *);
 	const char *(*get_desc) (alpm_pkg_t *);
 	const char *(*get_url) (alpm_pkg_t *);
-	char *(*get_note) (alpm_pkg_t *);
 	alpm_time_t (*get_builddate) (alpm_pkg_t *);
 	alpm_time_t (*get_installdate) (alpm_pkg_t *);
 	const char *(*get_packager) (alpm_pkg_t *);
@@ -94,7 +93,6 @@ struct _alpm_pkg_t {
 	char *version;
 	char *desc;
 	char *url;
-	char *note;
 	char *packager;
 	char *md5sum;
 	char *sha256sum;

lib/libalpm/trans.c

@@ -298,7 +298,6 @@ void _alpm_trans_free(alpm_trans_t *trans)
 	alpm_list_free(trans->add);
 	alpm_list_free_inner(trans->remove, (alpm_list_fn_free)_alpm_pkg_free);
 	alpm_list_free(trans->remove);
-	FREE(trans->note);
 
 	FREELIST(trans->skip_remove);
 
@@ -451,19 +450,3 @@ alpm_list_t SYMEXPORT *alpm_trans_get_remove(alpm_handle_t *handle)
 
 	return handle->trans->remove;
 }
-
-int SYMEXPORT alpm_trans_set_note(alpm_handle_t *handle, char *note) {
-	CHECK_HANDLE(handle, return -1);
-	ASSERT(handle->trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
-	ASSERT(handle->trans->state == STATE_INITIALIZED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
-
-	if(handle->trans->note) {
-		ASSERT(!strchr(handle->trans->note, '\n'), RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
-		free(handle->trans->note);
-		handle->trans->note = NULL;
-	}
-
-	STRDUP(handle->trans->note, note, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
-	return 0;
-}
-

lib/libalpm/trans.h

@@ -39,7 +39,6 @@ typedef enum _alpm_transstate_t {
 typedef struct _alpm_trans_t {
 	/* bitfield of alpm_transflag_t flags */
 	int flags;
-	char *note;
 	alpm_transstate_t state;
 	alpm_list_t *unresolvable;  /* list of (alpm_pkg_t *) */
 	alpm_list_t *add;           /* list of (alpm_pkg_t *) */

src/pacman/conf.c

@@ -155,7 +155,6 @@ int config_free(config_t *oldconfig)
 	free(oldconfig->dbpath);
 	free(oldconfig->logfile);
 	free(oldconfig->gpgdir);
-	free(oldconfig->note);
 	FREELIST(oldconfig->hookdirs);
 	FREELIST(oldconfig->cachedirs);
 	free(oldconfig->xfercommand);

src/pacman/conf.h

@@ -99,8 +99,6 @@ typedef struct __config_t {
 	unsigned int ask;
 	/* Bitfield of alpm_transflag_t */
 	int flags;
-	char *note;
-	int rmnote;
 	/* Bitfields of alpm_siglevel_t */
 	int siglevel;
 	int localfilesiglevel;
@@ -172,8 +170,6 @@ enum {
 	OP_IGNOREGROUP,
 	OP_NEEDED,
 	OP_ASEXPLICIT,
-	OP_NOTE,
-	OP_RMNOTE,
 	OP_ARCH,
 	OP_PRINTFORMAT,
 	OP_GPGDIR,

src/pacman/database.c

@@ -38,12 +38,11 @@
  *
  * @return 0 on success, 1 on failure
  */
-static int change_pkg(alpm_list_t *targets)
+static int change_install_reason(alpm_list_t *targets)
 {
 	alpm_list_t *i;
 	alpm_db_t *db_local;
 	int ret = 0;
-	int set_reason = 0;
 
 	alpm_pkgreason_t reason;
 
@@ -54,10 +53,11 @@ static int change_pkg(alpm_list_t *targets)
 
 	if(config->flags & ALPM_TRANS_FLAG_ALLDEPS) { /* --asdeps */
 		reason = ALPM_PKG_REASON_DEPEND;
-		set_reason = 1;
 	} else if(config->flags & ALPM_TRANS_FLAG_ALLEXPLICIT) { /* --asexplicit */
 		reason = ALPM_PKG_REASON_EXPLICIT;
-		set_reason = 1;
+	} else {
+		pm_printf(ALPM_LOG_ERROR, _("no install reason specified (use -h for help)\n"));
+		return 1;
 	}
 
 	/* Lock database */
@@ -69,46 +69,19 @@ static int change_pkg(alpm_list_t *targets)
 	for(i = targets; i; i = alpm_list_next(i)) {
 		char *pkgname = i->data;
 		alpm_pkg_t *pkg = alpm_db_get_pkg(db_local, pkgname);
-
-		if(!pkg) {
-			pm_printf(ALPM_LOG_ERROR, _("package '%s' was not found"), pkgname);
+		if(!pkg || alpm_pkg_set_reason(pkg, reason)) {
+			pm_printf(ALPM_LOG_ERROR, _("could not set install reason for package %s (%s)\n"),
+							pkgname, alpm_strerror(alpm_errno(config->handle)));
 			ret = 1;
-			continue;
-		}
-
-		if(set_reason) {
-			if(alpm_pkg_set_reason(pkg, reason)) {
-				pm_printf(ALPM_LOG_ERROR, _("could not set install reason for package %s (%s)\n"),
-								pkgname, alpm_strerror(alpm_errno(config->handle)));
-				ret = 1;
-			} else {
-				if(!config->quiet) {
-					if(reason == ALPM_PKG_REASON_DEPEND) {
-						printf(_("%s: install reason has been set to 'installed as dependency'\n"), pkgname);
-					} else {
-						printf(_("%s: install reason has been set to 'explicitly installed'\n"), pkgname);
-					}
+		} else {
+			if(!config->quiet) {
+				if(reason == ALPM_PKG_REASON_DEPEND) {
+					printf(_("%s: install reason has been set to 'installed as dependency'\n"), pkgname);
+				} else {
+					printf(_("%s: install reason has been set to 'explicitly installed'\n"), pkgname);
 				}
 			}
 		}
-
-		if(config->rmnote) {
-			if(alpm_pkg_set_note(pkg, NULL)) {
-				pm_printf(ALPM_LOG_ERROR, _("could not set install note for package %s (%s)\n"),
-								pkgname, alpm_strerror(alpm_errno(config->handle)));
-				ret = 1;
-			} else if(!config->quiet) {
-				printf(_("%s: note removed\n"), pkgname);
-			}
-		} else if(config->note) {
-			if(alpm_pkg_set_note(pkg, config->note)) {
-				pm_printf(ALPM_LOG_ERROR, _("could not set install note for package %s (%s)\n"),
-								pkgname, alpm_strerror(alpm_errno(config->handle)));
-				ret = 1;
-			} else if(!config->quiet) {
-				printf(_("%s: note set\n"), pkgname);
-			}
-		}
 	}
 
 	/* Unlock database */
@@ -323,9 +296,8 @@ int pacman_database(alpm_list_t *targets)
 		}
 	}
 
-	if(config->note || config->rmnote ||
-			(config->flags & (ALPM_TRANS_FLAG_ALLDEPS | ALPM_TRANS_FLAG_ALLEXPLICIT))) {
-		ret = change_pkg(targets);
+	if(config->flags & (ALPM_TRANS_FLAG_ALLDEPS | ALPM_TRANS_FLAG_ALLEXPLICIT)) {
+		ret = change_install_reason(targets);
 	}
 
 	return ret;

src/pacman/files.c

@@ -40,9 +40,8 @@ static void print_line_machinereadable(alpm_db_t *db, alpm_pkg_t *pkg, char *fil
 	fputs("\n", stdout);
 }
 
-static void dump_pkg_machinereadable(alpm_db_t *db, alpm_pkg_t *pkg)
+static void dump_pkg_machinereadable(alpm_db_t *db, alpm_pkg_t *pkg, alpm_filelist_t *pkgfiles)
 {
-	alpm_filelist_t *pkgfiles = alpm_pkg_get_files(pkg);
 	for(size_t filenum = 0; filenum < pkgfiles->count; filenum++) {
 		const alpm_file_t *file = pkgfiles->files + filenum;
 		print_line_machinereadable(db, pkg, file->name);
@@ -108,7 +107,9 @@ static void filetarget_free(struct filetarget *ftarg) {
 
 static int files_search(alpm_list_t *syncs, alpm_list_t *targets, int regex) {
 	int ret = 0;
-	alpm_list_t *t, *filetargs = NULL;
+	alpm_list_t *t, *s,  *filetargs = NULL;
+	alpm_filelist_t filelist = {0};
+	char *pkgname = NULL;
 
 	for(t = targets; t; t = alpm_list_next(t)) {
 		char *targ = t->data;
@@ -144,43 +145,58 @@ static int files_search(alpm_list_t *syncs, alpm_list_t *targets, int regex) {
 		goto cleanup;
 	}
 
-	for(t = filetargs; t; t = alpm_list_next(t)) {
-		struct filetarget *ftarg = t->data;
-		char *targ = ftarg->targ;
-		regex_t *reg = &ftarg->reg;
-		int exact_file = ftarg->exact_file;
-		alpm_list_t *s;
-		int found = 0;
+	for(s = syncs; s; s = alpm_list_next(s)) {
+		alpm_db_t *repo = s->data;
+		int m;
 
-		for(s = syncs; s; s = alpm_list_next(s)) {
-			alpm_list_t *p;
-			alpm_db_t *repo = s->data;
-			alpm_list_t *packages = alpm_db_get_pkgcache(repo);
-			int m;
+		alpm_db_files_t *files = alpm_db_files_open(repo);
 
-			for(p = packages; p; p = alpm_list_next(p)) {
-				alpm_pkg_t *pkg = p->data;
-				alpm_filelist_t *files = alpm_pkg_get_files(pkg);
+		if(!files) {
+			continue;
+		}
+
+		while(1) {
+			int ok = alpm_db_files_next(files, &pkgname);
+			if(ok == 1) {
+				break;
+			}
+			if(ok != 0) {
+				continue;
+			}
+
+			if(alpm_db_files_load(files, &filelist) != 0) {
+				ret = 1;
+				continue;
+			}
+
+			alpm_pkg_t *pkg = alpm_db_get_pkg(repo, pkgname);
+
+			for(t = filetargs; t; t = alpm_list_next(t)) {
+				struct filetarget *ftarg = t->data;
+				char *targ = ftarg->targ;
+				regex_t *reg = &ftarg->reg;
+				int exact_file = ftarg->exact_file;
+				int found = 0;
 				alpm_list_t *match = NULL;
 
 				if(exact_file) {
-					if (regex) {
-						for(size_t f = 0; f < files->count; f++) {
-							char *c = files->files[f].name;
+					if(regex) {
+						for(size_t f = 0; f < filelist.count; f++) {
+							char *c = filelist.files[f].name;
 							if(regexec(reg, c, 0, 0, 0) == 0) {
-								match = alpm_list_add(match, files->files[f].name);
+								match = alpm_list_add(match, filelist.files[f].name);
 								found = 1;
 							}
 						}
 					} else {
-						if(alpm_filelist_contains(files, targ)) {
+						if(alpm_filelist_contains(&filelist, targ)) {
 							match = alpm_list_add(match, targ);
 							found = 1;
 						}
 					}
 				} else {
-					for(size_t f = 0; f < files->count; f++) {
-						char *c = strrchr(files->files[f].name, '/');
+					for(size_t f = 0; f < filelist.count; f++) {
+						char *c = strrchr(filelist.files[f].name, '/');
 						if(c && *(c + 1)) {
 							if(regex) {
 								m = regexec(reg, (c + 1), 0, 0, 0);
@@ -188,7 +204,7 @@ static int files_search(alpm_list_t *syncs, alpm_list_t *targets, int regex) {
 								m = strcmp(c + 1, targ);
 							}
 							if(m == 0) {
-								match = alpm_list_add(match, files->files[f].name);
+								match = alpm_list_add(match, filelist.files[f].name);
 								found = 1;
 							}
 						}
@@ -199,28 +215,33 @@ static int files_search(alpm_list_t *syncs, alpm_list_t *targets, int regex) {
 					print_match(match, repo, pkg, exact_file);
 					alpm_list_free(match);
 				}
+
+				if(!found) {
+					ret = 1;
+				}
 			}
 		}
 
-		if(!found) {
-			ret = 1;
-		}
+		alpm_db_files_close(files);
 	}
 
 cleanup:
 	alpm_list_free_inner(filetargs, (alpm_list_fn_free) filetarget_free);
 	alpm_list_free(filetargs);
+	alpm_filelist_free(&filelist);
+
+	if(pkgname) {
+		free(pkgname);
+	}
 
 	return ret;
 }
 
-static void dump_file_list(alpm_pkg_t *pkg) {
+static void dump_file_list(alpm_pkg_t *pkg, alpm_filelist_t *pkgfiles) {
 	const char *pkgname;
-	alpm_filelist_t *pkgfiles;
 	size_t i;
 
 	pkgname = alpm_pkg_get_name(pkg);
-	pkgfiles = alpm_pkg_get_files(pkg);
 
 	for(i = 0; i < pkgfiles->count; i++) {
 		const alpm_file_t *file = pkgfiles->files + i;
@@ -239,73 +260,97 @@ static void dump_file_list(alpm_pkg_t *pkg) {
 static int files_list(alpm_list_t *syncs, alpm_list_t *targets) {
 	alpm_list_t *i, *j;
 	int ret = 0;
+	size_t found = 0;
+	alpm_filelist_t filelist = {0};
+	char *pkgname = NULL;
 
-	if(targets != NULL) {
-		for(i = targets; i; i = alpm_list_next(i)) {
-			int found = 0;
-			char *targ = i->data;
-			char *repo = NULL;
-			char *c = strchr(targ, '/');
+	for(j = syncs; j; j = alpm_list_next(j)) {
+		alpm_db_t *db = j->data;
+		alpm_db_files_t *files = alpm_db_files_open(db);
 
-			if(c) {
-				if(! *(c + 1)) {
-					pm_printf(ALPM_LOG_ERROR,
-						_("invalid package: '%s'\n"), targ);
-					ret += 1;
+		if(!files) {
+			continue;
+		}
+
+		while(1) {
+			int ok = alpm_db_files_next(files, &pkgname);
+			if(ok == 1) {
+				break;
+			}
+			if(ok != 0) {
+				continue;
+			}
+
+			if(targets != NULL) {
+				int match = 0;
+				for(i = targets; i; i = alpm_list_next(i)) {
+					char *targ =  i->data;
+					char *c = strchr(targ, '/');
+					char *repo = NULL;
+
+					if(c) {
+						if(! *(c + 1)) {
+							pm_printf(ALPM_LOG_ERROR,
+								_("invalid package: '%s'\n"), targ);
+							ret = 1;
+							continue;
+						}
+
+						repo = strndup(targ, c - targ);
+						targ = c + 1;
+					}
+
+					if(repo) {
+						if(strcmp(alpm_db_get_name(db), repo) != 0) {
+							free(repo);
+							continue;
+						}
+						free(repo);
+					}
+
+					if(strcmp(pkgname, targ) == 0) {
+						match = 1;
+						found++;
+						break;
+					}
+				}
+
+				if(!match) {
 					continue;
 				}
-
-				repo = strndup(targ, c - targ);
-				targ = c + 1;
 			}
 
-			for(j = syncs; j; j = alpm_list_next(j)) {
-				alpm_pkg_t *pkg;
-				alpm_db_t *db = j->data;
 
-				if(repo) {
-					if(strcmp(alpm_db_get_name(db), repo) != 0) {
-						continue;
-					}
-				}
+			if(alpm_db_files_load(files, &filelist) != 0) {
+				ret = 1;
+				continue;
+			}
 
-				if((pkg = alpm_db_get_pkg(db, targ)) != NULL) {
-					found = 1;
-					if(config->op_f_machinereadable) {
-						dump_pkg_machinereadable(db, pkg);
-					} else {
-						dump_file_list(pkg);
-					}
-					break;
-				}
+			alpm_pkg_t *pkg = alpm_db_get_pkg(db, pkgname);
+
+			if(config->op_f_machinereadable) {
+				dump_pkg_machinereadable(db, pkg, &filelist);
+			} else {
+				dump_file_list(pkg, &filelist);
 			}
-			if(!found) {
-				targ = i->data;
-				pm_printf(ALPM_LOG_ERROR,
-						_("package '%s' was not found\n"), targ);
-				ret += 1;
-			}
-			free(repo);
+			break;
 		}
-	} else {
-		for(i = syncs; i; i = alpm_list_next(i)) {
-		alpm_db_t *db = i->data;
+		alpm_db_files_close(files);
+	}
 
-			for(j = alpm_db_get_pkgcache(db); j; j = alpm_list_next(j)) {
-				alpm_pkg_t *pkg = j->data;
-				if(config->op_f_machinereadable) {
-					dump_pkg_machinereadable(db, pkg);
-				} else {
-					dump_file_list(pkg);
-				}
-			}
-		}
+	alpm_filelist_free(&filelist);
+
+	if(found != alpm_list_count(targets)) {
+		ret = 1;
+	}
+
+	if(pkgname) {
+		free(pkgname);
 	}
 
 	return ret;
 }
 
-
 int pacman_files(alpm_list_t *targets)
 {
 	alpm_list_t *files_dbs = NULL;

src/pacman/package.c

@@ -70,7 +70,6 @@ enum {
 	T_URL,
 	T_VALIDATED_BY,
 	T_VERSION,
-	T_NOTE,
 	/* the following is a sentinel and should remain in last position */
 	_T_MAX
 };
@@ -125,7 +124,6 @@ static void make_aligned_titles(void)
 	buf[T_URL] = _("URL");
 	buf[T_VALIDATED_BY] = _("Validated By");
 	buf[T_VERSION] = _("Version");
-	buf[T_NOTE] = _("Note");
 
 	for(i = 0; i < ARRAYSIZE(wbuf); i++) {
 		wlen[i] = mbstowcs(wbuf[i], buf[i], strlen(buf[i]) + 1);
@@ -303,7 +301,6 @@ void dump_pkg_full(alpm_pkg_t *pkg, int extra)
 	if(from == ALPM_PKG_FROM_LOCALDB) {
 		string_display(titles[T_INSTALL_DATE], idatestr, cols);
 		string_display(titles[T_INSTALL_REASON], reason, cols);
-		string_display(titles[T_NOTE], alpm_pkg_get_note(pkg), cols);
 	}
 	if(from == ALPM_PKG_FROM_FILE || from == ALPM_PKG_FROM_LOCALDB) {
 		string_display(titles[T_INSTALL_SCRIPT],

src/pacman/pacman.c

@@ -169,8 +169,6 @@ static void usage(int op, const char * const myname)
 			printf("%s:\n", str_opt);
 			addlist(_("      --asdeps         mark packages as non-explicitly installed\n"));
 			addlist(_("      --asexplicit     mark packages as explicitly installed\n"));
-			addlist(_("      --note <note>    add or edit a packages install notes\n"));
-			addlist(_("      --rmnote         remove install note from packages\n"));
 			addlist(_("  -k, --check          test local database for validity (-kk for sync databases)\n"));
 			addlist(_("  -q, --quiet          suppress output of success messages\n"));
 		} else if(op == PM_OP_DEPTEST) {
@@ -195,7 +193,6 @@ static void usage(int op, const char * const myname)
 				          "                       overwrite conflicting files (can be used more than once)\n"));
 				addlist(_("      --asdeps         install packages as non-explicitly installed\n"));
 				addlist(_("      --asexplicit     install packages as explicitly installed\n"));
-				addlist(_("      --note <note>    add an install note to packages\n"));
 				addlist(_("      --ignore <pkg>   ignore a package upgrade (can be used more than once)\n"));
 				addlist(_("      --ignoregroup <grp>\n"
 				          "                       ignore a group upgrade (can be used more than once)\n"));
@@ -484,12 +481,6 @@ static int parsearg_database(int opt)
 		case OP_ASEXPLICIT:
 			config->flags |= ALPM_TRANS_FLAG_ALLEXPLICIT;
 			break;
-		case OP_NOTE:
-			config->note = strdup(optarg);
-			break;
-		case OP_RMNOTE:
-			config->rmnote = 1;
-			break;
 		case OP_CHECK:
 		case 'k':
 			(config->op_q_check)++;
@@ -510,11 +501,7 @@ static void checkargs_database(void)
 			&& config->flags & ALPM_TRANS_FLAG_ALLEXPLICIT,
 			"--asdeps", "--asexplicit");
 
-	invalid_opt(config->note && config->rmnote, "--note", "--rmnote");
-
 	if(config->op_q_check) {
-	invalid_opt(config->note != NULL, "--note", "--check");
-	invalid_opt(config->rmnote, "--rmnote", "--check");
 		invalid_opt(config->flags & ALPM_TRANS_FLAG_ALLDEPS,
 				"--asdeps", "--check");
 		invalid_opt(config->flags & ALPM_TRANS_FLAG_ALLEXPLICIT,
@@ -741,9 +728,6 @@ static int parsearg_upgrade(int opt)
 		case OP_ASEXPLICIT:
 			config->flags |= ALPM_TRANS_FLAG_ALLEXPLICIT;
 			break;
-		case OP_NOTE:
-			config->note = strdup(optarg);
-			break;
 		case OP_NEEDED:
 			config->flags |= ALPM_TRANS_FLAG_NEEDED;
 			break;
@@ -958,8 +942,6 @@ static int parseargs(int argc, char *argv[])
 		{"ignoregroup", required_argument, 0, OP_IGNOREGROUP},
 		{"needed",     no_argument,       0, OP_NEEDED},
 		{"asexplicit",     no_argument,   0, OP_ASEXPLICIT},
-		{"note",       required_argument, 0, OP_NOTE},
-		{"rmnote",     no_argument,       0, OP_RMNOTE},
 		{"arch",       required_argument, 0, OP_ARCH},
 		{"print-format", required_argument, 0, OP_PRINTFORMAT},
 		{"gpgdir",     required_argument, 0, OP_GPGDIR},

src/pacman/query.c

@@ -329,15 +329,9 @@ static int display(alpm_pkg_t *pkg)
 			&& !config->op_q_changelog && !config->op_q_check) {
 		if(!config->quiet) {
 			const colstr_t *colstr = &config->colstr;
-			char *note = alpm_pkg_get_note(pkg);
-
 			printf("%s%s %s%s%s", colstr->title, alpm_pkg_get_name(pkg),
 					colstr->version, alpm_pkg_get_version(pkg), colstr->nocolor);
 
-			if(note) {
-				printf(" (%s)", note);
-			}
-
 			if(config->op_q_upgrade) {
 				int usage;
 				alpm_pkg_t *newpkg = alpm_sync_get_new_version(pkg, alpm_get_syncdbs(config->handle));

src/pacman/util.c

@@ -72,15 +72,6 @@ int trans_init(int flags, int check_valid)
 		trans_init_error();
 		return -1;
 	}
-
-	if(config->note) {
-		ret = alpm_trans_set_note(config->handle, config->note);
-		if(ret == -1) {
-			trans_init_error();
-			return -1;
-		}
-	}
-
 	return 0;
 }
 

test/pacman/meson.build

@@ -9,8 +9,6 @@ pacman_tests = [
   'tests/config002.py',
   'tests/database001.py',
   'tests/database002.py',
-  'tests/database003.py',
-  'tests/database004.py',
   'tests/database010.py',
   'tests/database011.py',
   'tests/database012.py',
@@ -176,7 +174,6 @@ pacman_tests = [
   'tests/symlink020.py',
   'tests/symlink021.py',
   'tests/sync-failover-404-with-body.py',
-  'tests/sync-keep-note.py',
   'tests/sync-install-assumeinstalled.py',
   'tests/sync-nodepversion01.py',
   'tests/sync-nodepversion02.py',
@@ -184,7 +181,6 @@ pacman_tests = [
   'tests/sync-nodepversion04.py',
   'tests/sync-nodepversion05.py',
   'tests/sync-nodepversion06.py',
-  'tests/sync-note-targets-only.py',
   'tests/sync-sysupgrade-print-replaced-packages.py',
   'tests/sync-update-assumeinstalled.py',
   'tests/sync-update-package-removing-required-provides.py',

test/pacman/pmdb.py

@@ -121,8 +121,6 @@ class pmdb(object):
                 pkg.groups = _getsection(fd)
             elif line == "%URL%":
                 pkg.url = fd.readline().strip("\n")
-            elif line == "%NOTE%":
-                pkg.note = fd.readline().strip("\n")
             elif line == "%LICENSE%":
                 pkg.license = _getsection(fd)
             elif line == "%ARCH%":
@@ -210,7 +208,6 @@ class pmdb(object):
             make_section(data, "INSTALLDATE", pkg.installdate)
             make_section(data, "SIZE", pkg.size)
             make_section(data, "REASON", pkg.reason)
-            make_section(data, "NOTE", pkg.note)
         else:
             make_section(data, "FILENAME", pkg.filename())
             make_section(data, "REPLACES", pkg.replaces)

test/pacman/pmpkg.py

@@ -34,7 +34,6 @@ class pmpkg(object):
         self.desc = ""
         self.groups = []
         self.url = ""
-        self.note = ""
         self.license = []
         self.arch = ""
         self.builddate = ""
@@ -72,7 +71,6 @@ class pmpkg(object):
         s.append("url: %s" % self.url)
         s.append("files: %s" % " ".join(self.files))
         s.append("reason: %d" % self.reason)
-        s.append("note: %s" % self.note)
         return "\n".join(s)
 
     def fullname(self):

test/pacman/pmrule.py

@@ -108,9 +108,6 @@ class pmrule(object):
                         if f.startswith(value + "\t"):
                             success = 1
                             break;
-                elif case == "NOTE":
-                    if newpkg.note != value:
-                        success = 0
                 else:
                     tap.diag("PKG rule '%s' not found" % case)
                     success = -1

test/pacman/pmtest.py

@@ -322,7 +322,7 @@ class pmtest(object):
                 self.result["success"] += 1
             else:
                 self.result["fail"] += 1
-            tap.ok(success == 1, i)
+            tap.ok(success, i)
 
     def configfile(self):
         return os.path.join(self.root, util.PACCONF)

test/pacman/tests/database003.py

@@ -1,10 +0,0 @@
-self.description = "-D --note :D"
-
-lp = pmpkg("pkg")
-self.addpkg2db("local", lp)
-
-self.args = "-D pkg --note :D"
-
-self.addrule("PACMAN_RETCODE=0")
-self.addrule("PKG_EXIST=pkg")
-self.addrule("PKG_NOTE=pkg|:D")

test/pacman/tests/database004.py

@@ -1,11 +0,0 @@
-self.description = "-D --rmnote"
-
-lp = pmpkg("pkg")
-lp.note = "D:"
-self.addpkg2db("local", lp)
-
-self.args = "-D pkg --rmnote"
-
-self.addrule("PACMAN_RETCODE=0")
-self.addrule("PKG_EXIST=pkg")
-self.addrule("PKG_NOTE=pkg|")

test/pacman/tests/sync-keep-note.py

@@ -1,14 +0,0 @@
-self.description = "Sync a package keeping the existing note"
-
-sp = pmpkg("pkg")
-self.addpkg2db("sync", sp)
-
-lp = pmpkg("pkg")
-lp.note = "this is a note"
-self.addpkg2db("local", lp)
-
-self.args = "-S pkg"
-
-self.addrule("PACMAN_RETCODE=0")
-self.addrule("PKG_EXIST=pkg")
-self.addrule("PKG_NOTE=pkg|this is a note")

test/pacman/tests/sync-note-targets-only.py

@@ -1,30 +0,0 @@
-self.description = "Make sure note is only set for targets"
-
-sp1 = pmpkg("pkg1", "1.0-2")
-sp1.depends = ["pkg2"]
-
-sp2 = pmpkg("pkg2")
-
-sp3 = pmpkg("pkg3")
-sp3.depends = ["pkg4"]
-
-sp4 = pmpkg("pkg4")
-
-for p in sp1, sp2, sp3, sp4:
-	self.addpkg2db("sync", p)
-
-lp1 = pmpkg("pkg1")
-self.addpkg2db("local", lp1)
-
-self.args = "-S pkg1 pkg3 --note aaaa"
-
-self.addrule("PACMAN_RETCODE=0")
-self.addrule("PKG_EXIST=pkg1")
-self.addrule("PKG_EXIST=pkg2")
-self.addrule("PKG_EXIST=pkg3")
-self.addrule("PKG_EXIST=pkg4")
-
-self.addrule("PKG_NOTE=pkg1|aaaa")
-self.addrule("PKG_NOTE=pkg2|")
-self.addrule("PKG_NOTE=pkg3|aaaa")
-self.addrule("PKG_NOTE=pkg4|")