ruby-rpm 1.2.2

data/ext/rpm/rpm40_compat.c

@@ -0,0 +1,28 @@
+/* -*- mode: C; c-basic-offset: 4; tab-width: 4; -*- */
+/* Ruby/RPM
+ *
+ * Copyright (C) 2004 YAMAZAKI Makoto <zaki@zakky.org>
+ */
+
+/* $Id: rpm40_compat.c 11 2004-03-13 14:54:21Z zaki $ */
+
+#include "private.h"
+
+
+#if RPM_VERSION(4,2,0) <= RPM_VERSION_CODE
+
+rpmRC
+rpmReadPackageInfo(FD_t fd, Header * sigp, Header * hdrp)
+{
+    rpmRC rc;
+
+    rpmts ts = rpmtsCreate();
+    rc = rpmReadPackageFile(ts, fd, "readRPM", hdrp);
+    ts = rpmtsFree(ts);
+    
+    if (sigp) *sigp = NULL;                 /* XXX HACK */
+
+    return rc;
+}
+
+#endif /* RPM_VERSION(4,2,0) <= RPM_VERSION_CODE */

data/ext/rpm/rpm40_compat.h

@@ -0,0 +1,9 @@
+#ifndef rpm40_compat_h_Included
+#define rpm40_compat_h_Included 1
+
+
+rpmRC
+rpmReadPackageInfo(FD_t fd, Header * sigp, Header * hdrp);
+
+
+#endif

data/ext/rpm/ruby-rpm.h

@@ -0,0 +1,181 @@
+/* -*- mode: C; c-basic-offset: 4; tab-width: 4; -*- */
+/* Ruby/RPM
+ *
+ * Copyright (C) 2002 Kenta MURATA <muraken2@nifty.com>.
+ */
+
+/* $Id: ruby-rpm.h 27 2004-05-23 04:54:24Z zaki $ */
+
+#ifndef ruby_rpm_h_Included
+#define ruby_rpm_h_Included 1
+
+#include <ruby.h>
+
+#define RUBY_RPM_VERSION "1.1.10"
+
+extern VALUE rpm_mRPM;
+extern VALUE rpm_cConflict;
+extern VALUE rpm_cDB;
+extern VALUE rpm_cDependency;
+extern VALUE rpm_cFile;
+extern VALUE rpm_cIcon;
+extern VALUE rpm_cMatchIterator;
+extern VALUE rpm_cObsolete;
+extern VALUE rpm_cPackage;
+extern VALUE rpm_cPatch;
+extern VALUE rpm_cProvide;
+extern VALUE rpm_cRequire;
+extern VALUE rpm_cSource;
+extern VALUE rpm_cSpec;
+extern VALUE rpm_cTransaction;
+extern VALUE rpm_cVersion;
+extern VALUE rpm_sChangeLog;
+extern VALUE rpm_sCallbackData;
+extern VALUE rpm_sProblem;
+
+/* db.c */
+VALUE rpm_db_open(int writable, const char* root);
+void rpm_db_init(const char* root, int writable);
+void rpm_db_rebuild(const char* root);
+VALUE rpm_db_get_root(VALUE db);
+VALUE rpm_db_get_home(VALUE db);
+VALUE rpm_db_is_writable(VALUE db);
+VALUE rpm_db_each_match(VALUE db, VALUE key, VALUE val);
+VALUE rpm_db_each(VALUE db);
+VALUE rpm_db_transaction(int argc, VALUE* argv, VALUE db);
+VALUE rpm_transaction_get_db(VALUE trans);
+VALUE rpm_transaction_get_script_file(VALUE trans);
+VALUE rpm_transaction_set_script_file(VALUE trans, VALUE file);
+VALUE rpm_transaction_install(VALUE trans, VALUE pkg, VALUE key);
+VALUE rpm_transaction_upgrade(VALUE trans, VALUE pkg, VALUE key);
+VALUE rpm_transaction_available(VALUE trans, VALUE pkg, VALUE key);
+VALUE rpm_transaction_delete(VALUE trans, VALUE name);
+VALUE rpm_transaction_check(VALUE trans);
+VALUE rpm_transaction_order(VALUE trans);
+VALUE rpm_transaction_keys(VALUE trans);
+VALUE rpm_transaction_commit(int argc, VALUE* argv, VALUE trans);
+VALUE rpm_transaction_abort(VALUE trans);
+VALUE rpm_db_init_iterator(VALUE db, VALUE key, VALUE val);
+VALUE rpm_mi_next_iterator(VALUE mi);
+VALUE rpm_mi_each(VALUE mi);
+VALUE rpm_mi_get_iterator_count(VALUE mi);
+VALUE rpm_mi_get_iterator_offset(VALUE mi);
+VALUE rpm_mi_set_iterator_re(VALUE mi,VALUE tag, VALUE mode, VALUE re);
+VALUE rpm_mi_set_iterator_version(VALUE mi, VALUE version);
+
+
+/* dependency.c */
+VALUE rpm_provide_new(const char* name, VALUE version, int flags, VALUE target);
+VALUE rpm_require_new(const char* name, VALUE version, int flags, VALUE target);
+VALUE rpm_conflict_new(const char* name, VALUE version, int flags, VALUE target);
+VALUE rpm_obsolete_new(const char* name, VALUE version, int flags, VALUE target);
+VALUE rpm_dependency_get_name(VALUE dep);
+VALUE rpm_dependency_get_version(VALUE dep);
+VALUE rpm_dependency_get_flags(VALUE dep);
+VALUE rpm_dependency_get_target(VALUE dep);
+VALUE rpm_dependency_is_lt(VALUE dep);
+VALUE rpm_dependency_is_gt(VALUE dep);
+VALUE rpm_dependency_is_eq(VALUE dep);
+VALUE rpm_dependency_is_le(VALUE dep);
+VALUE rpm_dependency_is_ge(VALUE dep);
+VALUE rpm_require_is_pre(VALUE req);
+VALUE rpm_dependency_get_nametag(VALUE dep);
+VALUE rpm_dependency_get_versiontag(VALUE dep);
+VALUE rpm_dependency_get_flagstag(VALUE dep);
+
+
+/* file.c */
+VALUE rpm_file_new(const char* path, const char* md5sum, const char* link_to,
+				   size_t size, time_t mtime, const char* owner, const char* group,
+				   dev_t rdev, mode_t mode, rpmfileAttrs attr, rpmfileState state);
+VALUE rpm_file_get_path(VALUE file);
+VALUE rpm_file_get_md5sum(VALUE file);
+VALUE rpm_file_get_link_to(VALUE file);
+VALUE rpm_file_get_size(VALUE file);
+VALUE rpm_file_get_mtime(VALUE file);
+VALUE rpm_file_get_owner(VALUE file);
+VALUE rpm_file_get_group(VALUE file);
+VALUE rpm_file_get_rdev(VALUE file);
+VALUE rpm_file_get_mode(VALUE file);
+VALUE rpm_file_get_attr(VALUE file);
+VALUE rpm_file_get_state(VALUE file);
+VALUE rpm_file_is_symlink(VALUE file);
+VALUE rpm_file_is_config(VALUE file);
+VALUE rpm_file_is_doc(VALUE file);
+VALUE rpm_file_is_donotuse(VALUE file);
+VALUE rpm_file_is_missingok(VALUE file);
+VALUE rpm_file_is_noreplace(VALUE file);
+VALUE rpm_file_is_specfile(VALUE file);
+VALUE rpm_file_is_ghost(VALUE file);
+VALUE rpm_file_is_license(VALUE file);
+VALUE rpm_file_is_readme(VALUE file);
+VALUE rpm_file_is_exclude(VALUE file);
+VALUE rpm_file_is_replaced(VALUE file);
+VALUE rpm_file_is_notinstalled(VALUE file);
+VALUE rpm_file_is_netshared(VALUE file);
+
+/* package.c */
+VALUE rpm_package_new_from_header(Header hdr);
+#if RPM_VERSION(4,1,0) <= RPM_VERSION_CODE
+VALUE rpm_package_new_from_N_EVR(VALUE name, VALUE version);
+#endif
+VALUE rpm_package_aref(VALUE pkg, VALUE tag);
+VALUE rpm_package_get_name(VALUE pkg);
+VALUE rpm_package_get_version(VALUE pkg);
+VALUE rpm_package_get_signature(VALUE pkg);
+VALUE rpm_package_get_files(VALUE pkg);
+VALUE rpm_package_get_provides(VALUE pkg);
+VALUE rpm_package_get_requires(VALUE pkg);
+VALUE rpm_package_get_conflicts(VALUE pkg);
+VALUE rpm_package_get_obsoletes(VALUE pkg);
+VALUE rpm_package_get_changelog(VALUE pkg);
+VALUE rpm_package_dump(VALUE pkg);
+VALUE rpm_package_add_dependency(VALUE pkg,VALUE dep);
+VALUE rpm_package_add_string(VALUE pkg,VALUE tag,VALUE val);
+VALUE rpm_package_add_string_array(VALUE pkg,VALUE tag,VALUE val);
+VALUE rpm_package_add_int32(VALUE pkg,VALUE tag,VALUE val);
+VALUE rpm_package_add_binary(VALUE pkg,VALUE tag,VALUE val);
+
+
+/* rpm.c */
+VALUE rpm_macro_aref(VALUE name);
+VALUE rpm_macro_aset(VALUE name, VALUE val);
+void rpm_readrc(const char* rcpath);
+void rpm_init_marcros(const char* path);
+VALUE rpm_get_verbosity(void);
+void rpm_set_verbosity(VALUE verbosity);
+
+/* source.c */
+VALUE rpm_source_new(const char* fullname, unsigned int num, int no);
+VALUE rpm_patch_new(const char* fullname, unsigned int num, int no);
+VALUE rpm_icon_new(const char* fullname, unsigned int num, int no);
+VALUE rpm_source_get_fullname(VALUE src);
+VALUE rpm_source_get_filename(VALUE src);
+VALUE rpm_source_get_num(VALUE src);
+VALUE rpm_source_is_no(VALUE src);
+
+/* spec.c */
+VALUE rpm_spec_open(const char* filename);
+VALUE rpm_spec_get_buildroot(VALUE spec);
+VALUE rpm_spec_get_buildsubdir(VALUE spec);
+VALUE rpm_spec_get_buildarchs(VALUE spec);
+VALUE rpm_spec_get_buildrequires(VALUE spec);
+VALUE rpm_spec_get_buildconflicts(VALUE spec);
+VALUE rpm_spec_get_build_restrictions(VALUE spec);
+VALUE rpm_spec_get_sources(VALUE spec);
+VALUE rpm_spec_get_packages(VALUE spec);
+
+/* version.c */
+VALUE rpm_version_new(const char* vr);
+VALUE rpm_version_new2(const char* vr, int e);
+VALUE rpm_version_new3(const char* v, const char* r, int e);
+VALUE rpm_version_cmp(VALUE ver, VALUE other);
+VALUE rpm_version_is_newer(VALUE ver, VALUE other);
+VALUE rpm_version_is_older(VALUE ver, VALUE other);
+VALUE rpm_version_get_v(VALUE ver);
+VALUE rpm_version_get_r(VALUE ver);
+VALUE rpm_version_get_e(VALUE ver);
+VALUE rpm_version_to_s(VALUE ver);
+VALUE rpm_version_to_vre(VALUE ver);
+
+#endif /* !ruby_rpm_h_Included */

data/ext/rpm/source.c

@@ -0,0 +1,152 @@
+/* -*- mode: C; c-basic-offset: 4; tab-width: 4; -*- */
+/* Ruby/RPM
+ *
+ * Copyright (C) 2002 Kenta MURATA <muraken2@nifty.com>.
+ */
+
+/* $Id: source.c 22 2004-03-29 03:42:35Z zaki $ */
+
+#include "private.h"
+
+VALUE rpm_cSource;
+VALUE rpm_cPatch;
+VALUE rpm_cIcon;
+
+static ID id_full;
+static ID id_fn;
+static ID id_num;
+static ID id_no;
+
+static VALUE
+source_initialize(int argc, VALUE* argv, VALUE src)
+{
+	switch (argc) {
+	case 0: case 1:
+		rb_raise(rb_eArgError, "argument too few(2..3)");
+
+	case 2: case 3:
+		if (TYPE(argv[0]) != T_STRING) {
+			rb_raise(rb_eTypeError, "illegal argument type");
+		}
+
+		rb_ivar_set(src, id_full, argv[0]);
+		rb_ivar_set(src, id_num, rb_Integer(argv[1]));
+		if (argc == 3) {
+			rb_ivar_set(src, id_no, RTEST(argv[2]) ? Qtrue : Qfalse);
+		} else {
+			rb_ivar_set(src, id_no, Qfalse);
+		}
+		break;
+
+	default:
+		rb_raise(rb_eArgError, "argument too many(2..3)");
+	}
+
+	return src;
+}
+
+VALUE
+rpm_source_new(const char* fullname, unsigned int num, int no)
+{
+	VALUE src, argv[3];
+
+	argv[0] = rb_str_new2(fullname);
+	argv[1] = UINT2NUM(num);
+	argv[2] = no ? Qtrue : Qfalse;
+
+	src = rb_newobj();
+	OBJSETUP(src, rpm_cSource, T_OBJECT);
+	rb_obj_call_init(src, 3, argv);
+
+	return src;
+}
+
+VALUE
+rpm_patch_new(const char* fullname, unsigned int num, int no)
+{
+	VALUE src, argv[3];
+
+	argv[0] = rb_str_new2(fullname);
+	argv[1] = UINT2NUM(num);
+	argv[2] = no ? Qtrue : Qfalse;
+
+	src = rb_newobj();
+	OBJSETUP(src, rpm_cPatch, T_OBJECT);
+	rb_obj_call_init(src, 3, argv);
+
+	return src;
+}
+
+VALUE
+rpm_icon_new(const char* fullname, unsigned int num, int no)
+{
+	VALUE src, argv[3];
+
+	argv[0] = rb_str_new2(fullname);
+	argv[1] = UINT2NUM(num);
+	argv[2] = no ? Qtrue : Qfalse;
+
+	src = rb_newobj();
+	OBJSETUP(src, rpm_cIcon, T_OBJECT);
+	rb_obj_call_init(src, 3, argv);
+
+	return src;
+}
+
+VALUE
+rpm_source_get_fullname(VALUE src)
+{
+	return rb_ivar_get(src, id_full);
+}
+
+VALUE
+rpm_source_get_filename(VALUE src)
+{
+	VALUE fn = rb_ivar_get(src, id_fn);
+
+	if (NIL_P(fn)) {
+		VALUE full = rb_ivar_get(src, id_full);
+		const char* p = strrchr(RSTRING(full)->ptr, '/');
+		if (p == NULL) {
+			p = RSTRING(full)->ptr;
+		} else {
+			p++;
+		}
+		fn = rb_str_new2(p);
+		rb_ivar_set(src, id_fn, fn);
+	}
+
+	return fn;
+}
+
+VALUE
+rpm_source_get_num(VALUE src)
+{
+	return rb_ivar_get(src, id_num);
+}
+
+VALUE
+rpm_source_is_no(VALUE src)
+{
+	return rb_ivar_get(src, id_no);
+}
+
+void
+Init_rpm_source(void)
+{
+	rpm_cSource = rb_define_class_under(rpm_mRPM, "Source", rb_cObject);
+	rb_define_method(rpm_cSource, "initialize", source_initialize, -1);
+	rb_define_method(rpm_cSource, "fullname", rpm_source_get_fullname, 0);
+	rb_define_alias(rpm_cSource, "to_s", "fullname");
+	rb_define_method(rpm_cSource, "filename", rpm_source_get_filename, 0);
+	rb_define_method(rpm_cSource, "num", rpm_source_get_num, 0);
+	rb_define_method(rpm_cSource, "no?", rpm_source_is_no, 0);
+
+	rpm_cPatch = rb_define_class_under(rpm_mRPM, "Patch", rpm_cSource);
+	rpm_cIcon = rb_define_class_under(rpm_mRPM, "Icon", rpm_cSource);
+
+	id_full = rb_intern("fullname");
+	id_fn = rb_intern("filename");
+	id_num = rb_intern("num");
+	id_no = rb_intern("no");
+}

data/ext/rpm/spec.c

@@ -0,0 +1,346 @@
+/* -*- mode: C; c-basic-offset: 4; tab-width: 4; -*- */
+/* Ruby/RPM
+ *
+ * Copyright (C) 2002 Kenta MURATA <muraken2@nifty.com>.
+ */
+
+/* $Id: spec.c 44 2004-06-03 16:58:10Z kazuhiko $ */
+
+#include "private.h"
+
+VALUE rpm_cSpec;
+
+static ID id_ba;
+static ID id_br;
+static ID id_bc;
+static ID id_src;
+static ID id_pkg;
+static ID id_rest;
+
+#if RPM_VERSION_CODE < RPM_VERSION(4,1,0)
+static void
+spec_free(Spec rspec)
+{
+	freeSpec(rspec);
+}
+
+#else
+static void
+ts_free(rpmts ts)
+{
+	ts = rpmtsFree(ts);
+}
+
+#endif
+
+static VALUE
+spec_s_open(VALUE klass, VALUE filename)
+{
+#if RPM_VERSION_CODE < RPM_VERSION(4,1,0)
+	Spec rspec;
+#else
+	rpmts ts = NULL;
+#endif
+
+	if (TYPE(filename) != T_STRING) {
+		rb_raise(rb_eTypeError, "illegal argument type");
+	}
+
+#if RPM_VERSION_CODE < RPM_VERSION(4,1,0)
+	switch (parseSpec(&rspec, RSTRING(filename)->ptr, "/", NULL, 0, "", NULL, 1, 1)) {
+	case 0:
+		if (rspec != NULL) {
+			break;
+		}
+
+	case RPMERR_BADSPEC:
+	default:
+		rb_raise(rb_eRuntimeError, "specfile `%s' parsing failed", RSTRING(filename)->ptr);
+	}
+	return Data_Wrap_Struct(klass, NULL, spec_free, rspec);
+#else
+	ts = rpmtsCreate();
+	switch (parseSpec(ts, RSTRING(filename)->ptr, "/", NULL, 0, "", NULL, 1, 1)) {
+	case 0:
+		if (ts != NULL) {
+			break;
+		}
+
+	case RPMERR_BADSPEC:
+	default:
+		rb_raise(rb_eRuntimeError, "specfile `%s' parsing failed", RSTRING(filename)->ptr);
+	}
+	return Data_Wrap_Struct(klass, NULL, ts_free, ts);
+#endif
+}
+
+VALUE
+rpm_spec_open(const char* filename)
+{
+	return spec_s_open(rpm_cSpec, rb_str_new2(filename));
+}
+
+VALUE
+rpm_spec_get_buildroot(VALUE spec)
+{
+	if (RPM_SPEC(spec)->buildRootURL) {
+		return rb_str_new2(RPM_SPEC(spec)->buildRootURL);
+	}
+	return Qnil;
+}
+
+VALUE
+rpm_spec_get_buildsubdir(VALUE spec)
+{
+	if (RPM_SPEC(spec)->buildSubdir) {
+		return rb_str_new2(RPM_SPEC(spec)->buildSubdir);
+	}
+	return Qnil;
+}
+
+VALUE
+rpm_spec_get_buildarchs(VALUE spec)
+{
+	VALUE ba = rb_ivar_get(spec, id_ba);
+
+	if (NIL_P(ba)) {
+		register int i;
+		ba = rb_ary_new();
+		for (i = 0; i < RPM_SPEC(spec)->BACount; i++) {
+			rb_ary_push(ba, rb_str_new2(RPM_SPEC(spec)->BANames[i]));
+		}
+		rb_ivar_set(spec, id_ba, ba);
+	}
+
+	return ba;
+}
+
+VALUE
+rpm_spec_get_buildrequires(VALUE spec)
+{
+	VALUE br = rb_ivar_get(spec, id_br);
+
+	if (NIL_P(br)) {
+		const char** names;
+		const char** vers;
+		int_32* flags;
+		int_32 count;
+		rpmTagType nt, vt, type;
+		register int i;
+
+		br = rb_ary_new();
+		if (!headerGetEntryMinMemory(RPM_SPEC(spec)->buildRestrictions,
+									 RPMTAG_REQUIRENAME, (hTYP_t)&nt,
+									 (hPTR_t*)&names, (hCNT_t)&count)) {
+			goto leave;
+		}
+
+		get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_REQUIREVERSION,
+				  &vt, (void*)&vers);
+		get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_REQUIREFLAGS,
+				  &type, (void*)&flags);
+
+		for (i = 0; i < count; i++) {
+			rb_ary_push(br, rpm_require_new(names[i], rpm_version_new(vers[i]),
+											flags[i], spec));
+		}
+
+		release_entry(nt, names);
+		release_entry(vt, vers);
+
+		rb_ivar_set(spec, id_br, br);
+	}
+
+ leave:
+	return br;
+}
+
+VALUE
+rpm_spec_get_buildconflicts(VALUE spec)
+{
+	VALUE bc = rb_ivar_get(spec, id_bc);
+
+	if (NIL_P(bc)) {
+		const char** names;
+		const char** vers;
+		int_32* flags;
+		int_32 count;
+		rpmTagType nt, vt, type;
+		register int i;
+
+		bc = rb_ary_new();
+		if (!headerGetEntryMinMemory(RPM_SPEC(spec)->buildRestrictions,
+									 RPMTAG_CONFLICTNAME, (hTYP_t)&nt,
+									 (hPTR_t*)&names, (hCNT_t)&count)) {
+			goto leave;
+		}
+
+		get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_CONFLICTVERSION,
+				  &vt, (void*)&vers);
+		get_entry(RPM_SPEC(spec)->buildRestrictions, RPMTAG_CONFLICTFLAGS,
+				  &type, (void*)&flags);
+
+		for (i = 0; i < count; i++) {
+			rb_ary_push(bc, rpm_conflict_new(names[i], rpm_version_new(vers[i]),
+											 flags[i], spec));
+		}
+
+		release_entry(nt, names);
+		release_entry(vt, vers);
+
+		rb_ivar_set(spec, id_bc, bc);
+	}
+ leave:
+	return bc;
+}
+
+VALUE
+rpm_spec_get_build_restrictions(VALUE spec)
+{
+	VALUE cache = rb_ivar_get(spec, id_rest);
+
+	if (NIL_P(cache)) {
+		cache = rpm_package_new_from_header(RPM_SPEC(spec)->buildRestrictions);
+		rb_ivar_set(spec, id_rest, cache);
+	}
+
+	return cache;
+}
+
+VALUE
+rpm_spec_get_sources(VALUE spec)
+{
+	VALUE src = rb_ivar_get(spec, id_src);
+
+	if (NIL_P(src)) {
+		struct Source* s = RPM_SPEC(spec)->sources;
+	   
+		src = rb_ary_new();
+		while (s != NULL) {
+			VALUE obj;
+
+			if (s->flags & RPMBUILD_ISSOURCE) {
+				obj = rpm_source_new(s->fullSource, s->num, s->flags & RPMBUILD_ISNO);
+			} else if (s->flags & RPMBUILD_ISPATCH) {
+				obj = rpm_patch_new(s->fullSource, s->num, s->flags & RPMBUILD_ISNO);
+			} else if (s->flags & RPMBUILD_ISICON) {
+				obj = rpm_icon_new(s->fullSource, s->num, s->flags & RPMBUILD_ISNO);
+			}
+
+			rb_ary_push(src, obj);
+			s = s->next;
+		}
+
+		rb_ivar_set(spec, id_src, src);
+	}
+
+	return src;
+}
+
+VALUE
+rpm_spec_get_packages(VALUE spec)
+{
+	VALUE pkg = rb_ivar_get(spec, id_pkg);
+
+	if (NIL_P(pkg)) {
+		Package p = RPM_SPEC(spec)->packages;
+
+		pkg = rb_ary_new();
+		while (p != NULL) {
+			if (p->fileList)
+				rb_ary_push(pkg, rpm_package_new_from_header(p->header));
+			p = p->next;
+		}
+
+		rb_ivar_set(spec, id_pkg, pkg);
+	}
+
+	return pkg;
+}
+
+VALUE
+rpm_spec_build(int argc, VALUE* argv, VALUE spec)
+{
+	int flags, test;
+	rpmRC rc;
+
+	switch (argc) {
+	case 0:
+		rb_raise(rb_eArgError, "argument too few(1..2)");
+
+	case 1:
+		flags = NUM2INT(argv[0]);
+		test = 0;
+		break;
+
+	case 2:
+		flags = NUM2INT(argv[0]);
+		test = RTEST(argv[1]);
+		break;
+
+	default:
+		rb_raise(rb_eArgError, "argument too many(0..1)");
+	}
+
+#if RPM_VERSION_CODE < RPM_VERSION(4,1,0)
+	rc = buildSpec(RPM_SPEC(spec), flags,test);
+#else
+	rpmts ts = NULL;
+	ts = rpmtsCreate();
+	rc = buildSpec(ts, RPM_SPEC(spec), flags,test);
+	ts_free(ts);
+#endif
+
+	return INT2NUM(rc);
+}
+
+VALUE
+rpm_spec_expand_macros(VALUE spec, VALUE name)
+{
+	char  buf[BUFSIZ];
+	char* tmp;
+	VALUE val;
+
+	if (TYPE(name) != T_STRING) {
+		rb_raise(rb_eTypeError, "illegal argument type");
+	}
+
+	sprintf(buf, "%%{%s}", RSTRING(name)->ptr);
+	tmp = strdup(buf);
+	expandMacros(RPM_SPEC(spec), RPM_SPEC(spec)->macros, buf, BUFSIZ);
+	if (strcmp(tmp, buf) == 0) {
+		val = Qnil;
+	} else {
+		val = rb_str_new2(buf);
+	}
+	free(tmp);
+
+	return val;
+}
+
+void
+Init_rpm_spec(void)
+{
+	rpm_cSpec = rb_define_class_under(rpm_mRPM, "Spec", rb_cData);
+	rb_define_singleton_method(rpm_cSpec, "open", spec_s_open, 1);
+	rb_define_singleton_method(rpm_cSpec, "new", spec_s_open, 1);
+	rb_define_method(rpm_cSpec, "buildroot", rpm_spec_get_buildroot, 0);
+	rb_define_method(rpm_cSpec, "buildsubdir", rpm_spec_get_buildsubdir, 0);
+	rb_define_method(rpm_cSpec, "buildarchs", rpm_spec_get_buildarchs, 0);
+	rb_define_method(rpm_cSpec, "buildrequires", rpm_spec_get_buildrequires, 0);
+	rb_define_method(rpm_cSpec, "buildconflicts", rpm_spec_get_buildconflicts, 0);
+	rb_define_method(rpm_cSpec, "build_restrictions", rpm_spec_get_build_restrictions, 0);
+	rb_define_method(rpm_cSpec, "sources", rpm_spec_get_sources, 0);
+	rb_define_method(rpm_cSpec, "packages", rpm_spec_get_packages, 0);
+	rb_define_method(rpm_cSpec, "build", rpm_spec_build, -1);
+	rb_define_method(rpm_cSpec, "expand_macros", rpm_spec_expand_macros, 1);
+	rb_undef_method(rpm_cSpec, "dup");
+	rb_undef_method(rpm_cSpec, "clone");
+
+	id_ba = rb_intern("buildarchs");
+	id_br = rb_intern("buildrequires");
+	id_bc = rb_intern("buildconflicts");
+	id_src = rb_intern("sources");
+	id_pkg = rb_intern("packages");
+	id_rest = rb_intern("build_restrictions");
+}