""" R2rpm launcher script """

  from r2spec.r2spec_obj import R2rpm, setup_parser

  from r2spec import R2specError

      ARG = PARSER.parse_args()

      try:

          R2rpm().main(ARG)

  """ R2spec launcher script """

  from r2spec.r2spec_obj import R2spec, setup_parser

  from r2spec import R2specError

      ARG = PARSER.parse_args()

      try:

          R2spec().main(ARG)

  """ Miscellaneous functions used in R2spec. """

  import logging

  import shutil

      Code from José Matos.

      :arg tag, the rpm tag to find the value of

      """

      return dirname

      """" Calls mock to retrieve the root path and return it minus the last

      two levels.

      """

      return dirname.rsplit('/', 3)[0] + '/'

      shutil.copyfile(fullpath, dest)

      """ R2specError class

      Template for all the error of the project

      """

  """ Build related class and methods. """

  import os

  import subprocess

                          self.rpm.append(rpm)

                      else:

                          self.rpm.append(rpm)

              self.log.info('Could not read the file "%s"' % self.buildlog)

              self.log.debug('ERROR: %s' % err)

              stream = open(self.buildlog, 'r')

              log = stream.read()

              stream.close()

              self.log.info('An error occured during the build')

              self.log.debug('ERROR: %s' % err)

              return(1)

          logs = log.split('\n')

  Main functions for R2spec

  """

  import argparse

  import logging

  import os

  import re

  import sys

  import pwd 

  from r2spec.build import Build

  from r2spec.rpackage import RPackage

      except OSError:

          # os.getlogin() raises an exception when the session is not

          # in /var/run/utmp (non-login sessions)

              packager = os.environ['LOGNAME']

          else:

              packager = pwd.getpwuid(os.getuid())[0]

          :arg configfile, name of the configuration file loaded.

          :arg sec, section of the configuration retrieved.

          """

          configfile = os.environ['HOME'] + "/" + configfile

          is_new = create_conf(configfile)

          parser.read(configfile)

          :arg key, name of the parameter to set from the settings.

          :arg value, value of the parameter to set from the settings.

          """

              raise KeyError(key)

          self._dict[key] = value

          :arg key, name of the parameter to retrieve from the settings.

          """

              raise KeyError(key)

          return self._dict[key]

          else:

              opts = set()

              value = None

              if name in opts:

                  value = parser.get(section, name)

              settings.set('email', args.email)

          if args.package:

              pack.search_package_in_repo()

          elif args.url:

              pack = RPackage(source0=args.url)

              self.log.info("RPM %s done" % specfile)

              # Get the list of rpm generated

              self.build.get_rpm()

              return False

          else:

              return True

          specfile = ''

          if args.package:

              self.spec.package = self.pack

              specfile = self.spec.get_specfile()

              self.pack.search_package_in_repo()

          self.spec.clean_files_section()

          self.spec.write_spec()

          self.build.build(specfile, mock_config=args.mock_config,

              mock_resultdir=args.mock_resultdir)

          if self.__check_build_output():

                  # Rebuild the package when build has failed the first time

                  if self.build.outcode:  # == 1 when build failed and 0 when build passed

                      self.build.build(specfile, mock_config=args.mock_config,

                          mock_resultdir=args.mock_resultdir)

                      self.__check_build_output()

                  self.log.info(err)

                  return 1

                  self.log.debug('Build ERROR: %s' % err)

                  return 1

          if not args.keep_logs:

  R packages class.

  """

  import os

  import re

  import shutil

  import sys

  import tarfile

  from tarfile import TarError

  from r2spec import get_logger, get_rpm_tag, R2specError

      """

      log = get_logger()

      try:

          stream.close()

          result = sourcemotif.search(content)

          if result is not None:

              log.info("Package found in : %s" % url)

              version = versionmotif.search(content).group(1).strip()

              return (version)

          else:

              log.info("Not Found: %s in %s" % (name, url))

          log.debug('Error: %s' % ex)

      return None

      def __init__(self, name=None, url=None, source0=None):

          """ Constructor. """

          self.name = name

          parser.read('/etc/R2spec/repos.cfg')

          self.config = parser

          self.log = get_logger()

              return

          url = self.source0.rsplit('/', 1)[0]

          self.log.info('Downloading %s' % url)

      def extract_sources(self):

          """ Extract the sources into the current directory. """

              tar = tarfile.open(tarball)

              tar.extractall()

              tar.close()

              self.log.debug("Error while extracting the tarball")

              self.log.debug("ERROR: %s" % err)

          :arg key, the key to retrieve from the DESCRIPTION file of the R

          package

          """

              return self.description[key]

          else:

              return ''

                  stream = open(description, 'r')

                  content = stream.read()

                  stream.close()

                  self.log.info(

                  'An error occured while reading the DESCRIPTION file: %s' \

                  % description)

              key = None

              for row in content.split('\n'):

                  if row.strip():

                      if pattern.match(row):

                          key, value = row.split(':', 1)

                          self.description[key.strip()] = value.strip()

      def read_config(self):

          """ Read the general configuration containing the repo information

          """

          configfile = '/etc/R2spec/config'

          parser.read(configfile)

          self.config = parser

          self.log.info('Removing extracted sources: "%s"' % self.name)

          try:

              shutil.rmtree(self.name)

              self.log.info('Could not remove the extracted sources: "%s"'\

                  % self.name)

              self.log.debug('ERROR: %s' % err)

          self.source0 = self.config.get(repo, 'source')

          if self.up_version != self.down_version:

              self.source0 = self.source0.replace('%{version}', self.up_version)

      def set_repo(self, reponame):

          """ This function find the URL and Source0 tag for the spec file

  Spec class, handles the read/write of the spec file

  """

  import datetime

  import os

      ignorelist = ['R']

      # Regular expression used to determine whether the string is a

      # version number

      char = {

              '\r': '',

              '(': ' ',

              '  ': ' ',

              }

          dependencies = dependencies.replace(key, char[key])

      dep_list = []

              stream.close()

              mytemplate = Template(tplfile)

              self.spec = mytemplate.render(self.__dict)

              self.log.debug('ERROR: %s' % err)

              raise R2specError('Cannot read the file %s' % template)

                  stream = open(specfile, 'r')

                  self.spec = stream.read()

                  stream.close()

                  self.log.info('Cannot read the file %s' % specfile)

                  self.log.debug('ERROR: %s' % err)

              stream.close()

              self.log.debug('Spec file writen: %s' % specfile)

              if verbose:

              self.log.info('Cannot write the file %s' % specfile)

              self.log.debug('ERROR: %s' % err)

  Setup script

  """

  from distutils.core import setup

  from r2spec import VERSION

  """ R2rpm tests script """

  # Cases:

  # -p <package>

  import shutil

  import sys

  import unittest

  sys.path.insert(0, os.path.abspath('../'))

  from r2spec.r2spec_obj import R2rpm, setup_parser

      :arg url, url to the object to download

      """

      sources = url.rsplit('/', 1)[1]

      return sources

          arg = parser.parse_args()

          try:

              R2rpm().main(arg)

              self.assertEqual('Not enough argument given, see -h/--help',

                  err.value)

  """ R2spec tests script """

  # Cases:

  # -p <package>

  import shutil

  import sys

  import unittest

  sys.path.insert(0, os.path.abspath('../'))

  from r2spec.r2spec_obj import R2spec, setup_parser

      :arg url, url to the object to download

      """

      sources = url.rsplit('/', 1)[1]

      return sources

          arg = parser.parse_args()

          try:

              R2spec().main(arg)

              self.assertEqual('Not enough argument given, see -h/--help',

                  err.value)

  """ R2spec launcher script """

  import unittest

  from test.test_R2spec import R2spectests

  from test.test_R2rpm import R2rpmtests