"""distutils.command.check

Implements the Distutils 'check' command.
"""
from distutils.core import Command
from distutils.errors import DistutilsSetupError

try:
 # docutils is installed
 from docutils.utils import Reporter
 from docutils.parsers.rst import Parser
 from docutils import frontend
 from docutils import nodes
 from io import StringIO

 class SilentReporter(Reporter):

 def __init__(self, source, report_level, halt_level, stream=None,
 debug=0, encoding='ascii', error_handler='replace'):
 self.messages = []
 Reporter.__init__(self, source, report_level, halt_level, stream,
 debug, encoding, error_handler)

 def system_message(self, level, message, *children, **kwargs):
 self.messages.append((level, message, children, kwargs))
 return nodes.system_message(message, level=level,
 type=self.levels[level],
 *children, **kwargs)

 HAS_DOCUTILS = True
except Exception:
 # Catch all exceptions because exceptions besides ImportError probably
 # indicate that docutils is not ported to Py3k.
 HAS_DOCUTILS = False

class check(Command):
 """This command checks the meta-data of the package.
 """
 description = ("perform some checks on the package")
 user_options = [('metadata', 'm', 'Verify meta-data'),
 ('restructuredtext', 'r',
 ('Checks if long string meta-data syntax '
 'are reStructuredText-compliant')),
 ('strict', 's',
 'Will exit with an error if a check fails')]

 boolean_options = ['metadata', 'restructuredtext', 'strict']

 def initialize_options(self):
 """Sets default values for options."""
 self.restructuredtext = 0
 self.metadata = 1
 self.strict = 0
 self._warnings = 0

 def finalize_options(self):
 pass

 def warn(self, msg):
 """Counts the number of warnings that occurs."""
 self._warnings += 1
 return Command.warn(self, msg)

 def run(self):
 """Runs the command."""
 # perform the various tests
 if self.metadata:
 self.check_metadata()
 if self.restructuredtext:
 if HAS_DOCUTILS:
 self.check_restructuredtext()
 elif self.strict:
 raise DistutilsSetupError('The docutils package is needed.')

 # let's raise an error in strict mode, if we have at least
 # one warning
 if self.strict and self._warnings > 0:
 raise DistutilsSetupError('Please correct your package.')

 def check_metadata(self):
 """Ensures that all required elements of meta-data are supplied.

 name, version, URL, (author and author_email) or
 (maintainer and maintainer_email)).

 Warns if any are missing.
 """
 metadata = self.distribution.metadata

 missing = []
 for attr in ('name', 'version', 'url'):
 if not (hasattr(metadata, attr) and getattr(metadata, attr)):
 missing.append(attr)

 if missing:
 self.warn("missing required meta-data: %s" % ', '.join(missing))
 if metadata.author:
 if not metadata.author_email:
 self.warn("missing meta-data: if 'author' supplied, " +
 "'author_email' must be supplied too")
 elif metadata.maintainer:
 if not metadata.maintainer_email:
 self.warn("missing meta-data: if 'maintainer' supplied, " +
 "'maintainer_email' must be supplied too")
 else:
 self.warn("missing meta-data: either (author and author_email) " +
 "or (maintainer and maintainer_email) " +
 "must be supplied")

 def check_restructuredtext(self):
 """Checks if the long string fields are reST-compliant."""
 data = self.distribution.get_long_description()
 for warning in self._check_rst_data(data):
 line = warning[-1].get('line')
 if line is None:
 warning = warning[1]
 else:
 warning = '%s (line %s)' % (warning[1], line)
 self.warn(warning)

 def _check_rst_data(self, data):
 """Returns warnings when the provided data doesn't compile."""
 # the include and csv_table directives need this to be a path
 source_path = self.distribution.script_name or 'setup.py'
 parser = Parser()
 settings = frontend.OptionParser(components=(Parser,)).get_default_values()
 settings.tab_width = 4
 settings.pep_references = None
 settings.rfc_references = None
 reporter = SilentReporter(source_path,
 settings.report_level,
 settings.halt_level,
 stream=settings.warning_stream,
 debug=settings.debug,
 encoding=settings.error_encoding,
 error_handler=settings.error_encoding_error_handler)

 document = nodes.document(settings, reporter, source=source_path)
 document.note_source(source_path, -1)
 try:
 parser.parse(data, document)
 except AttributeError as e:
 reporter.messages.append(
 (-1, 'Could not finish the parsing: %s.' % e, '', {}))

 return reporter.messages