@@ -4,107 +4,83 @@ import queue

 import json

 import operator

 from distutils.version import StrictVersion

-from SpecUtils import Specutils

 from Logger import Logger

 from constants import constants

 from StringUtils import StringUtils

 from distutils.version import LooseVersion

+from SpecParser import SpecParser

-class SpecObject(object):

-    def __init__(self):

-        self.listPackages = []

-        self.listRPMPackages = []

-        self.name = ""

-        self.version = ""

-        self.release = ""

-        self.buildarch = {}

-        self.buildRequiresAllPackages = []

-        self.checkBuildRequirePackages = []

-        self.installRequiresAllPackages = []

-        self.installRequiresPackages = {}

-        self.specFile = ""

-        self.listSources = []

-        self.checksums = {}

-        self.listPatches = []

-        self.securityHardening = ""

-        self.url = ""

-        self.sourceurl = ""

-        self.license = ""

-        self.specDefs = {}

-

-

-class SpecObjectsUtils(object):

-

-    def __init__(self, logPath):

+class SpecData(object):

+

+    def __init__(self, logPath, specFilesPath):

+

+        self.logger = Logger.getLogger("SpecData", logPath, constants.logLevel)

+

+        # map default package name to list of SpecObjects. Usually it is just

+        # a list with only one element. But, for multiversion spec file this

+        # list has as many elements as many versions of given package name

+        # are available

         self.mapSpecObjects = {}

+

+        # map subpackage names to default package name

         self.mapPackageToSpec = {}

+

+        # map spec file name to SpecObject

         self.mapSpecFileNameToSpecObj = {}

-        self.logger = Logger.getLogger("Serializable Spec objects", logPath, constants.logLevel)

-    def readSpecsAndConvertToSerializableObjects(self, specFilesPath):

-        listSpecFiles = []

-        self.getListSpecFiles(listSpecFiles, specFilesPath)

-        for specFile in listSpecFiles:

-            spec = Specutils(specFile)

-            specName = spec.getBasePackageName()

+        self._readSpecs(specFilesPath)

+

-            if (spec.getBuildArch(specName) != "noarch" and

-                    platform.machine() != spec.getBuildArch(specName)):

+    # Read all .spec files from the given folder including subfolders,

+    # creates corresponding SpecObjects and put them in internal mappings.

+    def _readSpecs(self, specFilesPath):

+        for specFile in self._getListSpecFiles(specFilesPath):

+            spec = SpecParser(specFile)

+

+            # skip the specfile if buildarch differs

+            buildarch = spec.packages.get('default').buildarch

+            if (buildarch != "noarch" and

+                    platform.machine() != buildarch):

                 self.logger.info("skipping spec file: "+str(specFile))

                 continue

-            specObj = SpecObject()

-            specObj.name = specName

-            specObj.buildRequiresAllPackages = spec.getBuildRequiresAllPackages()

-            specObj.extraBuildRequires = spec.getExtraBuildRequires()

-            specObj.installRequiresAllPackages = spec.getRequiresAllPackages()

-            specObj.checkBuildRequirePackages = spec.getCheckBuildRequiresAllPackages()

-            specObj.listPackages = spec.getPackageNames()

-            specObj.specFile = specFile

-            specObj.version = spec.getVersion()

-            specObj.release = spec.getRelease()

-            specObj.listSources = spec.getSourceNames()

-            specObj.checksums = spec.getChecksums()

-            specObj.specDefs = spec.getDefinitions()

-            specObj.listPatches = spec.getPatchNames()

-            specObj.securityHardening = spec.getSecurityHardeningOption()

-            specObj.isCheckAvailable = spec.isCheckAvailable()

-            specObj.license = spec.getLicense()

-            specObj.url = spec.getURL()

-            specObj.sourceurl = spec.getSourceURL()

+            specObj = spec.createSpecObject()

+

+            name = specObj.name

             for specPkg in specObj.listPackages:

-                specObj.installRequiresPackages[specPkg] = spec.getRequires(specPkg)

-                specObj.buildarch[specPkg] = spec.getBuildArch(specPkg)

-                # TODO add multiversioning support

-                self.mapPackageToSpec[specPkg] = specName

-                if spec.getIsRPMPackage(specPkg):

-                    specObj.listRPMPackages.append(specPkg)

-            if specName in self.mapSpecObjects:

-                self.mapSpecObjects[specName].append(specObj)

+                self.mapPackageToSpec[specPkg] = name

+

+            if name in self.mapSpecObjects:

+                self.mapSpecObjects[name].append(specObj)

             else:

-                self.mapSpecObjects[specName]=[specObj]

+                self.mapSpecObjects[name]=[specObj]

+

             self.mapSpecFileNameToSpecObj[os.path.basename(specFile)]=specObj

+

+        # Sort the multiversion list to make getHighestVersion happy

         for key, value in self.mapSpecObjects.items():

             if len(value) > 1:

                 self.mapSpecObjects[key] = sorted(value,

                                                   key=lambda x : self.compareVersions(x),

                                                   reverse=True)

-    def getListSpecFiles(self, listSpecFiles, path):

+    def _getListSpecFiles(self, path):

+        listSpecFiles = []

         for dirEntry in os.listdir(path):

             dirEntryPath = os.path.join(path, dirEntry)

             if (os.path.isfile(dirEntryPath) and

                     dirEntryPath.endswith(".spec")):

                 listSpecFiles.append(dirEntryPath)

             elif os.path.isdir(dirEntryPath):

-                self.getListSpecFiles(listSpecFiles, dirEntryPath)

+                listSpecFiles.extend(self._getListSpecFiles(dirEntryPath))

+        return listSpecFiles

     def _getProperVersion(self,depPkg):

         if (depPkg.compare == ""):

             return self.getHighestVersion(depPkg.package)

-        specObjs=self.getSpecObj(depPkg.package)

+        specObjs=self.getSpecObjects(depPkg.package)

         try:

             for obj in specObjs:

                 verrel=obj.version+"-"+obj.release

@@ -139,8 +115,7 @@ class SpecObjectsUtils(object):

                          " available specs:" + availableVersions)

     def _getSpecObjField(self, package, version, field):

-        specName = self.getSpecName(package)

-        for specObj in self.mapSpecObjects[specName]:

+        for specObj in self.getSpecObjects(package):

             if specObj.version == version:

                 return field(specObj)

         self.logger.error("Could not find " + package +

@@ -149,7 +124,7 @@ class SpecObjectsUtils(object):

     def getBuildRequiresForPackage(self, package, version):

         buildRequiresList=[]

-        for pkg in self._getSpecObjField(package, version, field=lambda x : x.buildRequiresAllPackages):

+        for pkg in self._getSpecObjField(package, version, field=lambda x : x.buildRequires):

             properVersion = self._getProperVersion(pkg)

             buildRequiresList.append(pkg.package+"-"+properVersion)

         return buildRequiresList

@@ -168,7 +143,7 @@ class SpecObjectsUtils(object):

     # Returns list of [ "pkg1-vers1", "pkg2-vers2",.. ]

     def getRequiresAllForPackage(self, package, version):

         requiresList=[]

-        for pkg in self._getSpecObjField(package, version, field=lambda x : x.installRequiresAllPackages):

+        for pkg in self._getSpecObjField(package, version, field=lambda x : x.installRequires):

             properVersion = self._getProperVersion(pkg)

             requiresList.append(pkg.package+"-"+properVersion)

         return requiresList

@@ -179,8 +154,7 @@ class SpecObjectsUtils(object):

     def getRequiresForPackage(self, package, version):

         requiresList=[]

-        specName = self.getSpecName(package)

-        for specObj in self.mapSpecObjects[specName]:

+        for specObj in self.getSpecObjects(package):

             if specObj.version == version:

                 if package in specObj.installRequiresPackages:

                     requiresPackages = specObj.installRequiresPackages[package]

@@ -198,13 +172,14 @@ class SpecObjectsUtils(object):

     def getCheckBuildRequiresForPackage(self, package, version):

         checkBuildRequiresList=[]

-        checkBuildRequiresPackages = self._getSpecObjField(package, version, field=lambda x : x.checkBuildRequirePackages)

+        checkBuildRequiresPackages = self._getSpecObjField(package, version, field=lambda x : x.checkBuildRequires)

         for pkg in checkBuildRequiresPackages:

             properVersion = self._getProperVersion(pkg)

             checkBuildRequiresList.append(pkg.package+"-"+properVersion)

         return checkBuildRequiresList

-    def getSpecObj(self, package):

+    # Returns list of SpecObjects for given subpackage name

+    def getSpecObjects(self, package):

         specName=self.getSpecName(package)

         return self.mapSpecObjects[specName]

@@ -219,14 +194,12 @@ class SpecObjectsUtils(object):

     def getVersions(self, package):

         versions=[]

-        specName = self.getSpecName(package)

-        for specObj in self.mapSpecObjects[specName]:

+        for specObj in self.getSpecObjects(package):

             versions.append(specObj.version)

         return versions

     def getHighestVersion(self, package):

-        specName = self.getSpecName(package)

-        return self.mapSpecObjects[specName][0].version

+        return self.getSpecObjects(package)[0].version

     def getBuildArch(self, package, version):

         return self._getSpecObjField(package, version, field=lambda x : x.buildarch[package])

@@ -315,9 +288,9 @@ class SpecObjectsUtils(object):

                 self.logger.debug("List RPM packages")

                 self.logger.debug(specObj.listPackages)

                 self.logger.debug("Build require packages")

-                self.logger.debug(self.getPkgNamesFromObj(specObj.buildRequiresAllPackages))

+                self.logger.debug(self.getPkgNamesFromObj(specObj.buildRequires))

                 self.logger.debug("install require packages")

-                self.logger.debug(self.getPkgNamesFromObj(specObj.installRequiresAllPackages))

+                self.logger.debug(self.getPkgNamesFromObj(specObj.installRequires))

                 self.logger.debug(specObj.installRequiresPackages)

                 self.logger.debug("security_hardening: " + specObj.securityHardening)

                 self.logger.debug("------------------------------------------------")

@@ -346,12 +319,13 @@ class SPECS(object):

         # Preparse some files

         # adding kernelversion rpm macro

-        spec = Specutils(constants.specPath + "/linux/linux.spec")

-        kernelversion = spec.getVersion()

+        spec = SpecParser(constants.specPath + "/linux/linux.spec")

+        defPkg = spec.packages.get('default')

+        kernelversion = defPkg.version

         constants.addMacro("KERNEL_VERSION", kernelversion)

         # adding kernelrelease rpm macro

-        kernelrelease = spec.getRelease()

+        kernelrelease = defPkg.release

         constants.addMacro("KERNEL_RELEASE", kernelrelease)

         # adding kernelsubrelease rpm macro

@@ -364,6 +338,5 @@ class SPECS(object):

             constants.addMacro("kernelsubrelease", kernelsubrelease)

         # Full parsing

-        self.specData = SpecObjectsUtils(constants.logPath)

-        self.specData.readSpecsAndConvertToSerializableObjects(constants.specPath)

+        self.specData = SpecData(constants.logPath, constants.specPath)

@@ -2,29 +2,40 @@

 import re

 import platform

 from StringUtils import StringUtils

-from SpecStructures import rpmMacro, dependentPackageData, Package

+from SpecStructures import dependentPackageData, Package, SpecObject

 from constants import constants

 class SpecParser(object):

-    def __init__(self):

-        self.cleanMacro = rpmMacro().setName("clean")

-        self.prepMacro = rpmMacro().setName("prep")

-        self.buildMacro = rpmMacro().setName("build")

-        self.installMacro = rpmMacro().setName("install")

-        self.changelogMacro = rpmMacro().setName("changelog")

-        self.checkMacro = rpmMacro().setName("check")

+    class rpmMacro(object):

+        def __init__(self):

+            self.macroName = ""

+            self.macroFlag = ""

+            self.content = ""

+            self.position = -1

+            self.endposition = -1

+

+    def __init__(self, specfile):

+        self.cleanMacro = None

+        self.prepMacro = None

+        self.buildMacro = None

+        self.installMacro = None

+        self.changelogMacro = None

+        self.checkMacro = None

         self.packages = {}

         self.specAdditionalContent = ""

         self.globalSecurityHardening = ""

         self.defs = {}

         self.conditionalCheckMacroEnabled = False

         self.macro_pattern = re.compile(r'%{(\S+?)\}')

+        self.specfile = specfile

-    def parseSpecFile(self, specfile):

-        self._createDefaultPackage()

+        self._parseSpecFile()

+

+    def _parseSpecFile(self):

+        self.packages["default"] = Package()

         currentPkg = "default"

-        with open(specfile) as specFile:

+        with open(self.specfile) as specFile:

             lines = specFile.readlines()

             totalLines = len(lines)

             i = 0

@@ -177,11 +188,8 @@ class SpecParser(object):

                 string = string.replace(macro, value)

         return re.sub(self.macro_pattern, _macro_repl, string)

-    def _createDefaultPackage(self):

-        self.packages["default"] = Package()

-

     def _readMacroFromFile(self, currentPos, lines):

-        macro = rpmMacro()

+        macro = self.rpmMacro()

         line = lines[currentPos]

         macro.position = currentPos

         macro.endposition = currentPos

@@ -208,23 +216,17 @@ class SpecParser(object):

     def _updateSpecMacro(self, macro):

         if macro.macroName == "%clean":

             self.cleanMacro = macro

-            return True

         if macro.macroName == "%prep":

             self.prepMacro = macro

-            return True

         if macro.macroName == "%build":

             self.buildMacro = macro

-            return True

         if macro.macroName == "%install":

             self.installMacro = macro

-            return True

         if macro.macroName == "%changelog":

             self.changelogMacro = macro

-            return True

         if macro.macroName == "%check":

             self.checkMacro = macro

-            return True

-        return False

+

     def _isMacro(self, line):

         return (self._isPackageMacro(line) or

                 self._isSpecMacro(line) or

@@ -495,3 +497,107 @@ class SpecParser(object):

     def _isConditionalMacroEnd(self, line):

         return line.strip() == "%endif"

+

+    ########################################################################

+    # SpecObject generating functions

+    ########################################################################

+

+    #

+    # @requiresType: "build" for BuildRequires or

+    #                "install" for Requires dependencies.

+    def _getRequiresTypeAllPackages(self, requiresType):

+        dependentPackages = []

+        for pkg in self.packages.values():

+            if requiresType == "build":

+                dependentPackages.extend(pkg.buildrequires)

+            elif requiresType == "install":

+                dependentPackages.extend(pkg.requires)

+        listDependentPackages = dependentPackages.copy()

+        packageNames = self._getPackageNames()

+        for pkg in self.packages.values():

+            for objName in listDependentPackages:

+                if objName.package == pkg.name:

+                        dependentPackages.remove(objName)

+        return dependentPackages

+

+    def _getCheckBuildRequiresAllPackages(self):

+        dependentPackages = []

+        for pkg in self.packages.values():

+            dependentPackages.extend(pkg.checkbuildrequires)

+        return dependentPackages

+

+    def _getExtraBuildRequires(self):

+        dependentPackages = []

+        for pkg in self.packages.values():

+            dependentPackages.extend(pkg.extrabuildrequires)

+        return dependentPackages

+

+    def _getPackageNames(self):

+        packageNames = []

+        for pkg in self.packages.values():

+            packageNames.append(pkg.name)

+        return packageNames

+

+    def _getSourceNames(self):

+        sourceNames = []

+        strUtils = StringUtils()

+        pkg = self.packages.get('default')

+        for source in pkg.sources:

+            sourceName = strUtils.getFileNameFromURL(source)

+            sourceNames.append(sourceName)

+        return sourceNames

+

+    def _getPatchNames(self):

+        patchNames = []

+        strUtils = StringUtils()

+        pkg = self.packages.get('default')

+        for patch in pkg.patches:

+            patchName = strUtils.getFileNameFromURL(patch)

+            patchNames.append(patchName)

+        return patchNames

+

+    def _getSourceURL(self):

+        pkg = self.packages.get('default')

+        if not pkg.sources:

+            return None

+        sourceURL = pkg.sources[0]

+        if sourceURL.startswith("http") or sourceURL.startswith("ftp"):

+            return sourceURL

+        return None

+

+    def _getRequires(self, pkgName):

+        dependentPackages = []

+        for pkg in self.packages.values():

+            if pkg.name == pkgName:

+                dependentPackages.extend(pkg.requires)

+        return dependentPackages

+

+    # Convert parsed data into SpecObject

+    def createSpecObject(self):

+        specObj = SpecObject()

+        specObj.specFile = self.specfile

+        defPkg = self.packages.get('default')

+        specObj.name = defPkg.name

+        specObj.version = defPkg.version

+        specObj.release = defPkg.release

+        specObj.checksums = defPkg.checksums

+        specObj.license = defPkg.license

+        specObj.url = defPkg.URL

+        specObj.securityHardening = self.globalSecurityHardening

+        specObj.isCheckAvailable = self.checkMacro is not None

+        specObj.buildRequires = self._getRequiresTypeAllPackages("build")

+        specObj.installRequires = self._getRequiresTypeAllPackages("install")

+        specObj.checkBuildRequires = self._getCheckBuildRequiresAllPackages()

+        specObj.extraBuildRequires = self._getExtraBuildRequires()

+        specObj.listPackages = self._getPackageNames()

+        specObj.listSources = self._getSourceNames()

+        specObj.listPatches = self._getPatchNames()

+        specObj.sourceurl = self._getSourceURL()

+

+        for pkg in self.packages.values():

+            specObj.installRequiresPackages[pkg.name] = pkg.requires

+            specObj.buildarch[pkg.name] = pkg.buildarch

+            if pkg.filesMacro:

+                specObj.listRPMPackages.append(pkg.name)

+

+        return specObj

@@ -1,24 +1,5 @@

 import platform

-class rpmMacro(object):

-

-    def __init__(self):

-        self.macroName = ""

-        self.macroFlag = ""

-        self.content = ""

-        self.position = -1

-        self.endposition = -1

-

-    def setName(self, name):

-        self.macroName = name

-

-    def displayMacro(self):

-        print("Macro:")

-        print(self.macroName + " {}".format(self.macroFlag)

-              + " {}".format(self.position)

-              + " {}".format(self.endposition))

-        print(self.content)

-

 class dependentPackageData(object):

     def __init__(self):

@@ -70,14 +51,40 @@ class Package(object):

     def updatePackageMacro(self, macro):

         if macro.macroName == "%post":

             self.postMacro = macro

-            return True

         if macro.macroName == "%postun":

             self.postunMacro = macro

-            return True

         if macro.macroName == "%files":

             self.filesMacro = macro

-            return True

         if macro.macroName == "%description":

             self.descriptionMacro = macro

-            return True

-        return False

+

+class SpecObject(object):

+    def __init__(self):

+        self.name = ""

+        self.version = ""

+        self.release = ""

+        # map subpackage name to its buildarch

+        self.buildarch = {}

+        # list of subpackage names

+        self.listPackages = []

+        # list of subpackage names that have %files section

+        self.listRPMPackages = []

+

+        # Next four lists store dependentPackageData objects

+        self.buildRequires = []

+        self.installRequires = []

+        self.checkBuildRequires = []

+        self.extraBuildRequires = []

+        # map subpackage name to list of install requires

+        # dependentPackageData objects

+        self.installRequiresPackages = {}

+

+        # full spec file name

+        self.specFile = ""

+        self.listSources = []

+        self.checksums = {}

+        self.listPatches = []

+        self.securityHardening = ""

+        self.url = ""

+        self.sourceurl = ""

+        self.license = ""

deleted file mode 100644

@@ -1,195 +0,0 @@

-# pylint: disable=invalid-name,missing-docstring

-import os

-from SpecParser import SpecParser

-from StringUtils import StringUtils

-

-class Specutils(object):

-

-    def __init__(self, specfile):

-        self.specfile = ""

-        self.spec = SpecParser()

-        if Specutils._isSpecFile(specfile):

-            self.specfile = specfile

-            self.spec.parseSpecFile(self.specfile)

-

-    @staticmethod

-    def _isSpecFile(specfile):

-        if os.path.isfile(specfile) and specfile.endswith(".spec"):

-            return True

-        return False

-

-    def getSourceNames(self):

-        sourceNames = []

-        strUtils = StringUtils()

-        pkg = self.spec.packages.get('default')

-        if pkg is None:

-            return None

-        for source in pkg.sources:

-            sourceName = strUtils.getFileNameFromURL(source)

-            sourceNames.append(sourceName)

-        return sourceNames

-

-    def getChecksums(self):

-        pkg = self.spec.packages.get('default')

-        return pkg.checksums

-

-    def getPatchNames(self):

-        patchNames = []

-        strUtils = StringUtils()

-        pkg = self.spec.packages.get('default')

-        if pkg is None:

-            return None

-        for patch in pkg.patches:

-            patchName = strUtils.getFileNameFromURL(patch)

-            patchNames.append(patchName)

-        return patchNames

-

-    def getPackageNames(self):

-        packageNames = []

-        for pkg in self.spec.packages.values():

-            packageNames.append(pkg.name)

-        return packageNames

-

-    def getIsRPMPackage(self, pkgName):

-        defaultPkgName = self.spec.packages['default'].name

-        if pkgName == defaultPkgName:

-            pkgName = "default"

-        if pkgName in self.spec.packages.keys():

-            pkg = self.spec.packages.get(pkgName)

-            if pkg.filesMacro is not None:

-                return True

-        return False

-

-    def getRPMNames(self):

-        rpmNames = []

-        for pkg in self.spec.packages.values():

-            rpmName = pkg.name + "-" + pkg.version + "-" + pkg.release

-            rpmNames.append(rpmName)

-        return rpmNames

-

-    def getLicense(self):

-        pkg = self.spec.packages.get('default')

-        if pkg is None:

-            return None

-        return pkg.license

-

-    def getBuildArch(self, pkgName):

-        for pkg in self.spec.packages.values():

-            if pkg.name == pkgName:

-                return pkg.buildarch

-        pkg = self.spec.packages.get('default')

-        return pkg.buildarch

-

-    def getURL(self):

-        pkg = self.spec.packages.get('default')

-        if pkg is None:

-            return None

-        return pkg.URL

-

-    def getSourceURL(self):

-        pkg = self.spec.packages.get('default')

-        if pkg is None:

-            return None

-        if not pkg.sources:

-            return None

-        sourceURL = pkg.sources[0]

-        if sourceURL.startswith("http") or sourceURL.startswith("ftp"):

-            return sourceURL

-        return None

-

-    # @requiresType: "build" for BuildRequires or

-    #                "install" for Requires dependencies.

-    def _getRequiresTypeAllPackages(self, requiresType):

-        dependentPackages = []

-        for pkg in self.spec.packages.values():

-            if requiresType == "build":

-                dependentPackages.extend(pkg.buildrequires)

-            elif requiresType == "install":

-                dependentPackages.extend(pkg.requires)

-        listDependentPackages = dependentPackages.copy()

-        packageNames = self.getPackageNames()

-        for pkgName in packageNames:

-            for objName in listDependentPackages:

-                if objName.package == pkgName:

-                        dependentPackages.remove(objName)

-        return dependentPackages

-

-    def getBuildRequiresAllPackages(self):

-        return self._getRequiresTypeAllPackages("build")

-

-    def getRequiresAllPackages(self):

-        return self._getRequiresTypeAllPackages("install")

-

-    def getCheckBuildRequiresAllPackages(self):

-        dependentPackages = []

-        for pkg in self.spec.packages.values():

-            dependentPackages.extend(pkg.checkbuildrequires)

-        return dependentPackages

-

-    def getExtraBuildRequires(self):

-        dependentPackages = []

-        for pkg in self.spec.packages.values():

-            dependentPackages.extend(pkg.extrabuildrequires)

-        return dependentPackages

-

-    def getRequires(self, pkgName):

-        dependentPackages = []

-        for pkg in self.spec.packages.values():

-            if pkg.name == pkgName:

-                dependentPackages.extend(pkg.requires)

-        return dependentPackages

-

-    def getProvides(self, packageName):

-        dependentPackages = []

-        defaultPkgName = self.spec.packages['default'].name

-        pkg = None

-        if packageName in self.spec.packages:

-            pkg = self.spec.packages.get(packageName)

-        if defaultPkgName == packageName:

-            pkg = self.spec.packages['default']

-        if pkg is not None:

-            for dpkg in pkg.provides:

-                dependentPackages.append(dpkg.package)

-        else:

-            print("package not found")

-        return dependentPackages

-

-    def getVersion(self):

-        pkg = self.spec.packages.get('default')

-        return pkg.version

-

-    def getRelease(self):

-        pkg = self.spec.packages.get('default')

-        return pkg.release

-

-    def getBasePackageName(self):

-        pkg = self.spec.packages.get('default')

-        return pkg.name

-

-    def getSecurityHardeningOption(self):

-        return self.spec.globalSecurityHardening

-

-    def isCheckAvailable(self):

-        check = False

-        if self.spec.checkMacro is not None:

-            check = True

-        return check

-

-    def getDefinitions(self):

-        return self.spec.defs

-

-def main():

-    spec = Specutils("/workspace1/myrepos/photon/SPECS/docker/docker.spec")

-    print("packages {}".format(spec.getPackageNames()))

-    print("packages {}".format(spec.getRPMNames()))

-    print("sources {}".format(spec.getSourceNames()))

-    print("patches {}".format(spec.getPatchNames()))

-    print("requires {}".format(spec.getRequires('libltdl-devel')))

-    print("requires {}".format(spec.getRequires('libtool')))

-

-    print("provides {}".format(spec.getProvides('libtool')))

-    print("all-requires {}".format(spec.getPkgNamesFromObj(spec.getRequiresAllPackages())))

-    print("all-build-requires {}".format(spec.getPkgNamesFromObj(spec.getBuildRequiresAllPackages())))

-

-if __name__ == '__main__':

-    main()