- python rpmfluff/__init__.py

- python3 rpmfluff/__init__.py

- python3 %{modname}/__init__.py

- 

- 

- UTF8ENCODE = None

- 

- CC = os.getenv("CC", "gcc")

- 

- def _utf8_encode(s):

-     """

-     RPM now returns all string data as surrogate-escaped utf-8 strings

-     so we need to introduce backwards compatible method to deal with that

-     """

-     global UTF8ENCODE

- 

-     if UTF8ENCODE is None:

-         h = rpm.hdr()

-         test = 'test'

-         h['name'] = test

-         UTF8ENCODE = (test != h['name'])

- 

-     if UTF8ENCODE:

-         return s.encode('utf-8')

-     else:

-         return s

- 

- def get_rpm_header(path):

-     assert(os.path.isfile(path))

-     ts = rpm.TransactionSet()

-     ts.setVSFlags(-1) # disable all verifications

-     fd = os.open(path, os.O_RDONLY)

-     try:

-         h = ts.hdrFromFdno(fd)

-         return h

-     finally:

-         os.close(fd)

- 

- def expand_macros(expr):

-     # If the expression contains RPM macros, return the expanded string

-     if '%' in expr:

-         return subprocess.check_output(['rpm', '-E', expr], universal_newlines=True).strip()

-     else:

-         return expr

- 

- class Check:

-     """

-     Something that ought to hold for the built RPMs

-     and can be checked automatically, and has a name via __str__

-     """

-     def check(self, build):

-         raise NotImplementedError

- 

-     def get_failure_message(self):

-         raise NotImplementedError

- 

- class FailedCheck(Exception):

-     """

-     Exception class representing a failed L{Check}

-     """

-     def __init__(self, check, extraInfo=None):

-         self.check = check

-         self.extraInfo = extraInfo

-         super(FailedCheck, self).__init__()

- 

-     def __str__(self):

-         s = self.check.get_failure_message()

-         if self.extraInfo:

-             return "%s (%s)"%(s, self.extraInfo)

-         else:

-             return s

- 

- class CheckPayloadFile(Check):

-     """Check that a built package contains a specified payload file or directory"""

-     def __init__(self, packageName, arch, fullPath):

-         self.packageName = packageName

-         self.arch = arch

-         self.fullPath = fullPath

- 

-     def __str__(self):

-         return 'Checking that %s RPM on %s contains payload file "%s"'%(self.packageName, self.arch, self.fullPath)

- 

-     def get_failure_message(self):

-         return '%s RPM on %s does not contain expected payload file "%s"'%(self.packageName, self.arch, self.fullPath)

- 

-     def check(self, build):

-         rpmHdr = build.get_built_rpm_header(self.arch, self.packageName)

-         if _utf8_encode(self.fullPath) not in rpmHdr[rpm.RPMTAG_FILENAMES]:

-             raise FailedCheck(self)

- 

- class CheckSourceFile(Check):

-     """Check that an SRPM contains the given source file"""

-     def __init__(self, name):

-         self.name = name

- 

-     def __str__(self):

-         return 'Checking that SRPM contains source file "%s"'%self.name

- 

-     def get_failure_message(self):

-         return 'SRPM does not contain expected source file "%s"'%(self.name)

- 

-     def check(self, build):

-         srpmHdr = build.get_built_srpm_header()

-         # The values in srpmHdr are binary strings, and self.name

-         # may not be a binary string, so encode self.name.

-         if _utf8_encode(self.name) not in srpmHdr[rpm.RPMTAG_FILENAMES]:

-             raise FailedCheck(self)

- 

- class CheckTrigger(Check):

-     """Check that a built package contains a specified L{Trigger}"""

-     def __init__(self, packageName, arch, trigger):

-         self.packageName = packageName

-         self.arch = arch

-         self.trigger = trigger

- 

-     def __str__(self):

-         return 'Checking that %s RPM on %s has trigger: %s'%(self.packageName, self.arch, self.trigger)

- 

-     def get_failure_message(self):

-         return '%s RPM on %s does not contain expected trigger "%s"'%(self.packageName, self.arch, self.trigger)

- 

-     def check(self, build):

-         rpmHdr = build.get_built_rpm_header(self.arch, self.packageName)

-         # Search by event type and trigger condition:

-         index = 0

-         for t in rpmHdr[rpm.RPMTAG_TRIGGERTYPE]:

-             # print(t)

-             # print(rpmHdr[rpm.RPMTAG_TRIGGERCONDS][index])

-             if t==_utf8_encode(self.trigger.event) and rpmHdr[rpm.RPMTAG_TRIGGERCONDS][index]==_utf8_encode(self.trigger.triggerConds):

-                 if rpmHdr[rpm.RPMTAG_TRIGGERSCRIPTS][index]!=_utf8_encode(self.trigger.script):

-                     raise FailedCheck(self, 'script "%s" did not match expected "%s"'%(rpmHdr[rpm.RPMTAG_TRIGGERSCRIPTS][index],self.trigger.script))

-                 expectedProgram = self.trigger.program

-                 if expectedProgram is None:

-                     expectedProgram = "/bin/sh"

-                 if rpmHdr[rpm.RPMTAG_TRIGGERSCRIPTPROG][index]!=_utf8_encode(expectedProgram):

-                     raise FailedCheck(self, 'executable "%s" did not match expected "%s"'%(rpmHdr[rpm.RPMTAG_TRIGGERSCRIPTPROG][index],expectedProgram))

- 

-                 # We have a match:

-                 return

-             # No match: try next one:

-             index += 1

-         # We din't find the trigger:

-         raise FailedCheck(self, 'trigger for event "%s" on "%s" not found within RPM'%(self.trigger.event, self.trigger.triggerConds))

- 

- class CheckRequires(Check):

-     def __init__(self, packageName, arch, requires):

-         self.packageName = packageName

-         self.arch = arch

-         self.requires = requires

- 

-     def __str__(self):

-         return 'Checking that %s RPM on %s has "Requires: %s"'%(self.packageName, self.arch, self.requires)

- 

-     def get_failure_message(self):

-         return '%s RPM on %s does not contain expected "Requires: %s"'%(self.packageName, self.arch, self.requires)

- 

-     def check(self, build):

-         rpmHdr = build.get_built_rpm_header(self.arch, self.packageName)

-         # Search by event type and trigger condition:

-         for t in rpmHdr[rpm.RPMTAG_REQUIRES]:

-             if t == self.requires:

-                 return  # found a match

- 

-         # We didn't find the requires:

-         raise FailedCheck(self)

- 

- class CheckProvides(Check):

-     def __init__(self, packageName, arch, provides):

-         self.packageName = packageName

-         self.arch = arch

-         self.provides = provides

- 

-     def __str__(self):

-         return 'Checking that %s RPM on %s has "Provides: %s"'%(self.packageName, self.arch, self.provides)

- 

-     def get_failure_message(self):

-         return '%s RPM on %s does not contain expected "Provides %s"'%(self.packageName, self.arch, self.provides)

- 

-     def check(self, build):

-         rpmHdr = build.get_built_rpm_header(self.arch, self.packageName)

-         # Search by event type and trigger condition:

-         for t in rpmHdr[rpm.RPMTAG_PROVIDES]:

-             if t == self.provides:

-                 return  # found a match

- 

-         # We didn't find the provides:

-         raise FailedCheck(self)

- 

- # Should scrap these in favour of strings, for base64 encoded files

- class FileConstraint:

-     """

-     Abstract base class for describing innards of a file

-     """

-     def affect_file(self, dstFile):

-         raise NotImplementedError

- 

- class BytesAt(FileConstraint):

-     """

-     Class representing byte values at an offset in a file

-     """

-     def __init__(self, offset, values):

-         self.offset = offset

-         self.values = values

- 

-     def affect_file(self, dstFile):

-         dstFile.seek(self.offset)

-         dstFile.write(self.values)

- 

- def make_png():

-     return [BytesAt(0, b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52"

-                        b"\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4"

-                        b"\x89\x00\x00\x00\x0a\x49\x44\x41\x54\x78\x9c\x63\x00\x01\x00\x00"

-                        b"\x05\x00\x01\x0d\x0a\x2d\xb4\x00\x00\x00\x00\x49\x45\x4e\x44\xae"

-                        b"\x42\x60\x82")]

- 

- def make_gif():

-     return [BytesAt(0, b"GIF89a\x01\x00\x01\x00\x00\x00\x00\x3b")]

- 

- def make_elf(bit_format=64):

-     """

-     See https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header

-     """

-     if bit_format == 64:

-         return [BytesAt(0, b"\177ELF\002")]

-     elif bit_format == 32:

-         return [BytesAt(0, b"\177ELF\001")]

-     else:

-         raise Exception("make_elf: unknown bit format")

- 

- class Buildable:

-     def is_up_to_date(self):

-         raise NotImplementedError

- 

-     def make(self):

-         # print("considering building %s"%self)

-         if not self.is_up_to_date():

-             # print("doing it!")

-             self.do_make()

- 

-     def clean(self):

-         raise NotImplementedError

- 

-     def do_make(self):

-         raise NotImplementedError

- 

- class RpmBuild(Buildable):

-     """

-     Wrapper for an invocation of rpmbuild

-     """

-     def __init__(self, buildArchs=None):

-         """

-         buildArchs:

-             if None, the build will happen on the current arch

-             if non-None, should be a list of strings: the archs to build on

-         """

-         self.buildArchs = buildArchs

- 

-     def is_up_to_date(self):

-         # FIXME: crude check for now: does the build dir exist?

-         if os.path.isdir(self.get_base_dir()):

-             return True

-         return False

- 

-     def get_base_dir(self):

-         """Determine the name of the base directory of the rpmbuild hierarchy"""

-         raise NotImplementedError

- 

-     def clean(self):

-         shutil.rmtree(self.get_base_dir(), ignore_errors=True)

- 

-     def sanitize_string(self, name):

-         """Strip what can be dangerous for filenames"""

-         return re.sub('[^a-zA-Z0-9._-]', '_', name)

- 

-     def __create_directories(self):

-         """Sets up the directory hierarchy for the build"""

-         os.mkdir(self.get_base_dir())

- 

-         # Make fake rpmbuild directories

-         for subDir in ['BUILD', 'SOURCES', 'SRPMS', 'RPMS']:

-             os.mkdir(os.path.join(self.get_base_dir(), subDir))

- 

-     def do_make(self):

-         """

-         Hook to actually perform the rpmbuild, gathering the necessary source files first

-         """

-         self.clean()

- 

-         self.__create_directories()

- 

-         specFileName = self.gather_spec_file(self.get_base_dir())

- 

-         sourcesDir = self.get_sources_dir()

-         self.gather_sources(sourcesDir)

- 

-         absBaseDir = os.path.abspath(self.get_base_dir())

- 

-         buildArchs = ()

-         if self.buildArchs:

-             buildArchs = self.buildArchs

-         else:

-             buildArchs = (expectedArch,)

-         for arch in buildArchs:

-             command = ["rpmbuild", "--define", "_topdir %s" % absBaseDir,

-                        "--define", "_rpmfilename %%{ARCH}/%%{NAME}-%%{VERSION}-%%{RELEASE}.%%{ARCH}.rpm",

-                        "-ba", "--target", arch, specFileName]

-             try:

-                 log = subprocess.check_output(command, stderr=subprocess.STDOUT).splitlines(True)

-             except subprocess.CalledProcessError as e:

-                 raise RuntimeError('rpmbuild command failed with exit status %s: %s\n%s'

-                         % (e.returncode, e.cmd, e.output))

-             self.__write_log(log, arch)

- 

-         self.check_results()

- 

-     def __write_log(self, log, arch):

-         log_dir = self.get_build_log_dir(arch)

-         if not os.path.exists(log_dir):

-             os.makedirs(log_dir)

-         filename = self.get_build_log_path(arch)

-         f = open(filename, "wb")

-         for line in log:

-             f.write(line)

-         f.close()

- 

-     def get_build_log_dir(self, arch):

-         """For the sake of standardization, write build logs to $basedir/LOGS/$arch/build.log"""

-         return os.path.join(self.get_base_dir(), "LOGS", arch)

- 

-     def get_build_log_path(self, arch):

-         """For the sake of standardization, write build logs to $basedir/LOGS/$arch/build.log"""

-         return os.path.join(self.get_build_log_dir(arch), "build.log")

- 

-     def get_build_dir(self):

-         return os.path.join(self.get_base_dir(), "BUILD")

- 

-     def get_sources_dir(self):

-         return os.path.join(self.get_base_dir(), "SOURCES")

- 

-     def get_srpms_dir(self):

-         return os.path.join(self.get_base_dir(), "SRPMS")

- 

-     def get_rpms_dir(self):

-         return os.path.join(self.get_base_dir(), "RPMS")

- 

-     def gather_sources(self, sourcesDir):

-         """

-         Pure virtual hook for gathering source for the build to the given location

-         """

-         raise NotImplementedError

- 

-     def gather_spec_file(self, tmpDir):

-         """

-         Pure virtual hook for gathering specfile for the build to the appropriate location

- 

-         @return: full path/name of specfile

-         """

-         raise NotImplementedError

- 

-     def check_results(self):

-         """

-         Pure virtual hook for performing checks upon the results of the build

-         """

-         raise NotImplementedError

- 

- class SourceFile:

-     def __init__(self, sourceName, content, encoding = 'utf8'):

-         self.sourceName = sourceName

-         self.content = content

-         self.encoding = encoding

- 

-     def _get_dst_file(self, sourcesDir):

-         import codecs

-         dstFileName = os.path.join(sourcesDir, self.sourceName)

-         if isinstance(self.content, bytes):

-             dstFile = open(dstFileName, "wb")

-         else:

-             dstFile = codecs.open(dstFileName, "wb", self.encoding)

-         return dstFile

- 

-     def write_file(self, sourcesDir):

-         dstFile = self._get_dst_file(sourcesDir)

-         dstFile.write(self.content)

-         dstFile.close()

- 

- class GeneratedSourceFile:

-     def __init__(self, sourceName, fileConstraints):

-         self.sourceName = sourceName

-         self.fileConstraints = fileConstraints

- 

-     def _get_dst_file(self, sourcesDir):

-         dstFileName = os.path.join(sourcesDir, self.sourceName)

-         dstFile = open(dstFileName, 'wb')

-         return dstFile

- 

-     def write_file(self, sourcesDir):

-         dstFile = self._get_dst_file(sourcesDir)

-         for c in self.fileConstraints:

-             c.affect_file(dstFile)

-         dstFile.close()

- 

- class ExternalSourceFile:

-     def __init__(self, sourceName, path):

-         self.sourceName = sourceName

-         self.path = path

- 

-     def _get_dst_file(self, sourcesDir):

-         dstFileName = os.path.join(sourcesDir, self.sourceName)

-         dstFile = open(dstFileName, 'wb')

-         return dstFile

- 

-     def write_file(self, sourcesDir):

-         dstFile = self._get_dst_file(sourcesDir)

-         for line in open(self.path):

-             dstFile.write(line)

- 

- class GeneratedTarball:

-     def __init__(self, sourceName, internalPath, contents):

-         self.sourceName = sourceName

-         self.internalPath = internalPath

-         self.contents = contents

- 

-     def write_file(self, sourcesDir):

-         shutil.rmtree(self.internalPath, ignore_errors=True)

-         os.mkdir(self.internalPath)

-         for content in self.contents:

-             content.write_file(self.internalPath)

- 

-         compressionOption = '--gzip'

-         cmd = ["tar", "--create", compressionOption,

-                 "--file", os.path.join(sourcesDir, self.sourceName), self.internalPath]

-         subprocess.check_call(cmd)

-         shutil.rmtree(self.internalPath)

- 

- 

- hello_world = """#include <stdio.h>

- 

- int

- main (int argc, char **argv)

- {

-     printf ("Hello world\\n");

- 

-     return 0;

- }

- """

- 

- hello_world_patch = r"""--- main.c.old       2007-04-09 13:23:51.000000000 -0400

- +++ main.c     2007-04-09 13:24:12.000000000 -0400

- @@ -3,7 +3,7 @@

-  int

-  main (int argc, char **argv)

-  {

- -    printf ("Hello world\n");

- +    printf ("Foo\n");

- 

-      return 0;

-  }

- """

- 

- simple_library_source = """#include <stdio.h>

- 

- void greet(const char *message)

- {

-     printf ("%s\\n", message);

- }

- """

- 

- 

- defaultChangelogFormat = """* Sun Jul 22 2018 John Doe <jdoe@example.com> - %s-%s

- - Initial version

- """

- 

- sample_man_page = """.TH FOO "1" "May 2009" "foo 1.00" "User Commands"

- .SH NAME

- foo \\- Frobnicates the doohickey

- .SH SYNOPSIS

- .B foo

- [\\fIOPTION\\fR]...

- 

- .SH DESCRIPTION

- A sample manpage

- """

- 

- def get_expected_arch():

-     # FIXME: do this by directly querying rpm python bindings:

-     evalArch = subprocess.check_output(['rpm', '--eval', '%{_arch}'])

- 

-     # first line of output, losing trailing carriage return

-     # convert to a unicode type for python3

-     return evalArch.strip().decode('ascii')

- 

- expectedArch = get_expected_arch()

- 

- def can_compile_m32():

-     # 64-bit hosts can compile 32-bit binaries by using -m32, but only if the 

-     # necessary bits are installed (they are often not).

-     return os.path.exists('/usr/include/gnu/stubs-32.h') and os.path.exists('/lib/libgcc_s.so.1')

- 

- def can_use_rpm_weak_deps():

-     return int(rpm.__version_info__[0]) >= 4 and int(rpm.__version_info__[1]) >= 12

- 

- class Trigger:

-     def __init__(self, event, triggerConds, script, program=None):

-         """For documentation on RPM triggers, see

-         U{http://www.rpm.org/support/RPM-Changes-6.html}

- 

-         @param event: can be:

-           - "un"

-           - "in"

-           - "postun"

-         @type event: string

- 

-         @param triggerConds: the name of the target package, potentially with a conditional, e.g.:

-           "sendmail"

-           "fileutils > 3.0, perl < 1.2"

-         @type triggerConds: string

- 

-         @param script: textual content of the script to execute

-         @type script: string

- 

-         @param program: the progam used to execute the script

-         @type program: string

-         """

-         self.event = event

-         self.triggerConds = triggerConds

-         self.script = script

-         self.program = program

- 

-     def output(self, specFile, subpackageName=""):

-         # Write trigger line:

-         specFile.write("%%trigger%s %s"%(self.event, subpackageName))

-         if self.program:

-             specFile.write("-p %s"%self.program)

-         specFile.write(" -- %s\n"%self.triggerConds)

- 

-         # Write script:

-         specFile.write("%s\n"%self.script)

- 

-     def __str__(self):

-         result = "%%trigger%s "%(self.event)

-         if self.program:

-             result += "-p %s"%self.program

-         result += " -- %s\n"%self.triggerConds

-         result += "%s\n"%self.script

-         return result

- 

- class Subpackage:

-     def __init__(self, suffix):

-         """

-         @param suffix: the suffix part of the name.  For example, a

-         "foo-devel" subpackage of "foo" has name "devel"

-         """

-         self.suffix = suffix

- 

-         # Provide some sane defaults which rpmlint won't complain about:

-         self.group = "Applications/Productivity"

-         self.summary = "Dummy summary"

-         self.description = "This is a dummy description."

- 

-         self.section_requires = ""

-         self.section_recommends = ""

-         self.section_suggests = ""

-         self.section_supplements = ""

-         self.section_enhances = ""

-         self.section_provides = ""

-         self.section_obsoletes = ""

-         self.section_conflicts = ""

-         self.section_files = ""

- 

-         self.section_pre = ""

-         self.section_post = ""

-         self.section_preun = ""

-         self.section_postun = ""

- 

-         self.triggers = []

- 

-     def add_group(self, groupName):

-         "Add a group name to the .spec file"

-         self.group = groupName

- 

-     def add_description(self, descriptiveText):

-         "Change the default description for the rpm"

-         self.description = descriptiveText

- 

-     def add_summary(self, summaryText):

-         "Change the default summary text for the rpm.  You can describe the test, or ways in which the rpm is intentionally defective."

-         self.summary = summaryText

- 

-     def add_requires(self, requirement):

-         "Add a Requires: line"

-         self.section_requires += "Requires: %s\n"%requirement

- 

-     def add_suggests(self, suggestion):

-         "Add a Suggests: line"

-         self.section_suggests += "Suggests: %s\n"%suggestion

- 

-     def add_supplements(self, supplement):

-         "Add a Supplements: line"

-         self.section_supplements += "Supplements: %s\n"%supplement

- 

-     def add_enhances(self, enhancement):

-         "Add a Requires: line"

-         self.section_enhances += "Enhances: %s\n"%enhancement

- 

-     def add_recommends(self, recommendation):

-         "Add a Recommends: line"

-         self.section_recommends += "Recommends: %s\n"%recommendation

- 

-     def add_provides(self, capability):

-         "Add a Provides: line"

-         self.section_provides += "Provides: %s\n"%capability

- 

-     def add_obsoletes(self, obsoletes):

-         "Add a Obsoletes: line"

-         self.section_obsoletes += "Obsoletes: %s\n"%obsoletes

- 

-     def add_conflicts(self, conflicts):

-         "Add a Conflicts: line"

-         self.section_conflicts += "Conflicts: %s\n"%conflicts

- 

-     def add_pre(self, preLine):

-         self.section_pre += preLine

- 

-     def add_post(self, postLine):

-         self.section_post += postLine

- 

-     def add_preun(self, preunLine):

-         self.section_preun += preunLine

- 

-     def add_postun(self, postunLine):

-         self.section_postun += postunLine

- 

-     def add_trigger(self, trigger):

-         "Add a trigger"

-         self.triggers.append(trigger)

- 

-     def write_triggers(self, specFile):

-         for trigger in self.triggers:

-             trigger.output(specFile, self.suffix)

- 

- class SimpleRpmBuild(RpmBuild):

-     """A wrapper for rpmbuild that also provides a canned way of generating a

-     specfile and the source files."""

-     def __init__(self, name, version, release, buildArchs=None):

-         RpmBuild.__init__(self, buildArchs)

- 

-         self.specfileEncoding = 'utf-8'

- 

-         self.checks = []

- 

-         self.header = "# autogenerated specfile\n"

-         self.name = self.sanitize_string(name)

-         self.epoch = None

-         self.version = self.sanitize_string(version)

-         self.release = self.sanitize_string(release)

-         # Provide sane default which rpmlint won't complain about:

-         self.license = "GPL"

-         self.vendor = ""

-         self.packager = ""

-         self.url = ""

- 

-         self.basePackage = Subpackage('')

-         self.subPackages = []

- 

-         self.makeDebugInfo = False

- 

-         self.sources = {}

-         self.patches = {}

- 

-         self.section_sources = ""

-         self.section_patches = ""

-         self.section_prep = ""

-         self.section_build = ""

-         self.section_clean = "rm -rf $$RPM_BUILD_ROOT"

-         self.section_install = ""

- 

-         self.section_pre = ""

-         self.section_post = ""

-         self.section_preun = ""

-         self.section_postun = ""

- 

-         self.section_changelog = defaultChangelogFormat%(version, release)

- 

-         self.specbasename = None

- 

-     def get_base_dir(self):

-         return "test-rpmbuild-%s-%s-%s" % (self.name, self.version, expand_macros(self.release))

- 

-     def get_subpackage_names(self):

-         """

-         @return: generates a list of subpackage names: e.g.

-           ['foo', 'foo-devel', 'foo-debuginfo']

-         """

-         result = [self.name]

-         for sub in self.subPackages:

-             result.append("%s-%s"%(self.name, sub.suffix))

-         if self.makeDebugInfo:

-             result.append("%s-debuginfo"%self.name)

-         return result

- 

-     def get_subpackage_name(self, suffix):

-         if suffix is not None:

-             return '%s-%s' % (self.name, suffix)

-         else:

-             return self.name

- 

-     def get_subpackage(self, suffix):

-         """

-         @return: get a subpackage by suffix (e.g. "devel"), or None/"" for the base package

-         """

-         if suffix==None or suffix=='':

-             return self.basePackage

- 

-         for sub in self.subPackages:

-             if suffix == sub.suffix:

-                 return sub

-         # Not found:

-         return None

- 

-     def gather_sources(self, sourcesDir):

-         #print(self.sources)

-         for source in list(self.sources.values()):

-             source.write_file(sourcesDir)

-         for patch in list(self.patches.values()):

-             patch.write_file(sourcesDir)

- 

-     def add_summary(self, summaryText):

-         "Change the default summary text for this package"

-         self.basePackage.add_summary(summaryText)

- 

-     def add_group(self, groupText):

-         "Change the default group text for this package"

-         self.basePackage.add_group(groupText)

- 

-     def add_description(self, descriptiveText):

-         "Change the default description text for this package"

-         self.basePackage.add_description(descriptiveText)

- 

-     def addLicense(self, licenseName):

-         "Set License"

-         self.license = licenseName

- 

-     def addVendor(self, vendorName):

-         "Set Vendor name"

-         self.vendor = vendorName

- 

-     def addPackager(self, packagerName):

-         "Set Packager name"

-         self.packager = packagerName

- 

-     def addUrl(self, urlName):

-         "Set URL"

-         self.url = urlName

- 

-     def addSpecBasename(self, name):

-         "Set spec file basename to NAME for NAME.spec"

-         self.specbasename = name

- 

-     def add_pre(self, preLine):

-         "Append a line to the %pre script section of this package"

-         self.section_pre += preLine

- 

-     def add_post(self, postLine):

-         "Append a line to the %post script section of this package"

-         self.section_post += postLine

- 

-     def add_preun(self, preunLine):

-         "Append a line to the %preun script section of this package"

-         self.section_preun += preunLine

- 

-     def add_postun(self, postunLine):

-         "Append a line to the %postun script section of this package"

-         self.section_postun += postunLine

- 

-     def gather_spec_file(self, tmpDir):

-         import codecs

-         if self.specbasename and self.specbasename != '':

-             specFileName = os.path.join(tmpDir, "%s.spec" % self.specbasename)

-         else:

-             specFileName = os.path.join(tmpDir, "%s.spec"%self.name)

-         specFile = codecs.open(specFileName, "wb", self.specfileEncoding)

-         specFile.write(self.header)

-         specFile.write("Summary: %s\n"%self.basePackage.summary)

-         specFile.write("Name: %s\n"%self.name)

-         if self.epoch:

-             specFile.write("Epoch: %s\n"%self.epoch)

-         specFile.write("Version: %s\n"%self.version)

-         specFile.write("Release: %s\n"%self.release)

-         if self.license:

-             specFile.write("License: %s\n"%self.license)

-         specFile.write("Group: %s\n"%self.basePackage.group)

-         if self.vendor:

-             specFile.write("Vendor: %s\n"%self.vendor)

-         if self.packager:

-             specFile.write("Packager: %s\n"%self.packager)

-         if self.url:

-             specFile.write("URL: %s\n"%self.url)

-         specFile.write("\n")

-         specFile.write("BuildRoot: %(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)\n")

- 

-         # FIXME: ExclusiveArch

- 

-         specFile.write(self.section_sources)

-         specFile.write(self.section_patches)

- 

-         specFile.write(self.basePackage.section_requires)

-         specFile.write(self.basePackage.section_recommends)

-         specFile.write(self.basePackage.section_suggests)

-         specFile.write(self.basePackage.section_supplements)

-         specFile.write(self.basePackage.section_enhances)

-         specFile.write(self.basePackage.section_provides)

-         specFile.write(self.basePackage.section_obsoletes)

-         specFile.write(self.basePackage.section_conflicts)

- 

-         specFile.write("\n")

- 

-         specFile.write("%description\n")

-         specFile.write("%s\n"%self.basePackage.description)

-         specFile.write("\n")

- 

-         for sub in self.subPackages:

-             specFile.write("%%package %s\n"%sub.suffix)

-             specFile.write("Group: %s\n"%sub.group)

-             specFile.write("Summary: %s\n"%sub.summary)

-             specFile.write(sub.section_requires)

-             specFile.write(sub.section_provides)

-             specFile.write(sub.section_obsoletes)

-             specFile.write(sub.section_conflicts)

-             specFile.write("\n")

-             specFile.write("%%description %s\n"%sub.suffix)

-             specFile.write("%s\n"%sub.description)

-             specFile.write("\n")

- 

-         specFile.write("%prep\n")

-         specFile.write(self.section_prep)

-         specFile.write("\n")

- 

-         specFile.write("%build\n")

-         specFile.write(self.section_build)

-         specFile.write("\n")

-