spec-cleaner 1.2.3__py3-none-any.whl

spec_cleaner/__init__.py

@@ -0,0 +1,170 @@
+# vim: set ts=4 sw=4 et: coding=UTF-8
+
+# Copyright (c) 2015, SUSE LINUX Products GmbH, Nuernberg, Germany
+# All rights reserved.
+# See COPYING for details.
+
+"""Spec-cleaner formatting module."""
+
+import argparse
+import os
+import sys
+from datetime import datetime
+from typing import Any, Dict, List
+
+from .rpmcleaner import RpmSpecCleaner
+from .rpmexception import RpmExceptionError, RpmWrongArgsError
+
+__version__ = '1.2.3'
+
+
+def process_args(argv: List[str]) -> Dict[str, Any]:
+    """
+    Parse and process commandline arguments.
+
+    Args:
+        argv: A list of passed arguments.
+
+    Returns:
+        A dict mapping arguments to the corresponding values.
+
+    Raises:
+        RpmWrongArgsError: If the specfile doesn't exist or
+                      if the output file already exists but '--force' option (overwrite the output) wasn't used.
+    """
+    parser = argparse.ArgumentParser(
+        prog='spec-cleaner',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        description='Cleans the given spec file according to style guide and returns the result. If "#nospeccleaner"'
+        'tag is used in the spec file than the spec file will not be cleaned.',
+    )
+
+    # Make the -d, -i, and -o exclusive as we can do only one of those
+    output_group = parser.add_mutually_exclusive_group()
+
+    parser.add_argument('specfile', metavar='SPEC', type=str, help='spec file to beautify')
+    parser.add_argument(
+        '-c',
+        '--cmake',
+        action='store_true',
+        help='convert dependencies to their cmake() counterparts, requires bit more of cleanup in spec afterwards.',
+    )
+    output_group.add_argument(
+        '-d',
+        '--diff',
+        action='store_true',
+        help='run the diff program to show differences between new and original specfile.',
+    )
+    parser.add_argument(
+        '--diff-prog', default='vimdiff', help='specify the diff binary to call with diff option.',
+    )
+    parser.add_argument(
+        '-f', '--force', action='store_true', help='overwrite the output file if already exist.',
+    )
+    output_group.add_argument(
+        '-i',
+        '--inline',
+        action='store_true',
+        help='inline the changes directly to the parsed file.',
+    )
+    parser.add_argument(
+        '-m',
+        '--minimal',
+        action='store_true',
+        help='run in minimal mode that does not do anything intrusive (ie. just sets the Copyright)',
+    )
+    parser.add_argument(
+        '--no-curlification',
+        action='store_true',
+        help='do not convert variables bracketing (%%{macro}) and keep it as it was on the input',
+    )
+    parser.add_argument(
+        '--no-copyright',
+        action='store_true',
+        help='do not include official SUSE copyright hear and just keep what is present',
+    )
+    parser.add_argument(
+        '--remove-groups', action='store_true', help='remove groups from the specfile.'
+    )
+    parser.add_argument(
+        '--copyright-year',
+        metavar='YYYY',
+        type=int,
+        default=datetime.now().year,
+        help='year to insert into the copyright header when re-generating it',
+    )
+    output_group.add_argument(
+        '-o', '--output', default='', help='specify the output file for the cleaned spec content.',
+    )
+    parser.add_argument(
+        '-p',
+        '--pkgconfig',
+        action='store_true',
+        help='convert dependencies to their pkgconfig() counterparts, requires bit more of cleanup in spec afterwards.',
+    )
+    parser.add_argument(
+        '--perl',
+        action='store_true',
+        help='convert dependencies to their perl() counterparts, highly expansive use carefully',
+    )
+    parser.add_argument(
+        '-t',
+        '--tex',
+        action='store_true',
+        help='convert dependencies to their tex() counterparts, requires verification of the output afterwards.',
+    )
+    parser.add_argument(
+        '-v',
+        '--version',
+        action='version',
+        version=__version__,
+        help='show package version and exit',
+    )
+    parser.add_argument(
+        '-k', '--keep-space', action='store_true', help='keep empty lines in preamble intact.',
+    )
+
+    # print help if there is no argument
+    if len(argv) < 1:
+        parser.print_help()
+        sys.exit(0)
+
+    options = parser.parse_args(args=argv)
+
+    # the spec must exist for us to do anything
+    if not os.path.exists(options.specfile):
+        raise RpmWrongArgsError('{0} does not exist.'.format(options.specfile))
+
+    # the path for output must exist and the file must not be there unless
+    # force is specified
+    if options.output:
+        options.output = os.path.expanduser(options.output)
+        if not options.force and os.path.exists(options.output):
+            raise RpmWrongArgsError('{0} already exists.'.format(options.output))
+
+    # convert options to dict
+    options_dict = vars(options)
+    return options_dict
+
+
+def main() -> int:
+    """
+    Run main function.
+
+    It calls argument parsing ensures their sanity and then creates
+    RpmSpecCleaner object that works with passed spec file.
+    """
+    try:
+        options = process_args(sys.argv[1:])
+    except RpmWrongArgsError as exception:
+        sys.stderr.write('ERROR: {0}\n'.format(exception))
+        return 1
+
+    try:
+        cleaner = RpmSpecCleaner(options)
+        cleaner.run()
+    except RpmExceptionError as exception:
+        sys.stderr.write('ERROR: {0}\n'.format(exception))
+        return 1
+
+    return 0

spec_cleaner/__main__.py

@@ -0,0 +1,11 @@
+import os
+import sys
+
+from spec_cleaner import main
+
+path = os.path.dirname(os.path.dirname(__file__))
+sys.path.insert(0, path)
+
+
+if __name__ == '__main__':
+    sys.exit(main())

spec_cleaner/dependency_parser.py

@@ -0,0 +1,273 @@
+import logging
+import re
+
+from .rpmexception import NoMatchExceptionError
+from .rpmrequirestoken import RpmRequiresToken
+
+chunk_types = ('text', 'space', 'macro', 'operator', 'version')
+
+state_types = ('start', 'name', 'operator', 'version')
+
+re_brackets = {}
+re_brackets['('] = re.compile(
+    r'(' + r'\(' + r'|' + r'\)' + r'|' + r'\\(' + r'|' + r'\\)' + r'|' + r'[^\()]+' + r')'
+)
+
+re_brackets['{'] = re.compile(
+    r'(' + r'\{' + r'|' + r'\}' + r'|' + r'\\{' + r'|' + r'\\}' + r'|' + r'[^\{}]+' + r')'
+)
+
+re_name = re.compile(r'[-A-Za-z0-9_~(){}@:;.+/*\[\]]+')
+re_version = re.compile(r'[-A-Za-z0-9_~():.+]+')
+re_spaces = re.compile(r'(\s*,\s*|\s+)')
+re_macro_unbraced = re.compile('%[A-Za-z0-9_]{3,}')
+re_version_operator = re.compile('(>=|<=|=>|=<|>|<|=)')
+
+logger = logging.getLogger('DepParser')
+# Switch to logging.DEBUG if needed
+logger.setLevel(logging.ERROR)
+
+
+def find_end_of_bracketed_macro(string, regex, opening, closing):
+    """Find the end of bracketed macros."""
+    # ommit the initial bracket, or %bracket
+    if string.startswith('%'):
+        macro = string[0:2]
+        string = string[2:]
+    else:
+        macro = string[0:1]
+        string = string[1:]
+    opened = 1
+    while opened and string:
+        try:
+            bite, string = consume_chars(regex, string)
+        except NoMatchExceptionError:
+            raise Exception('unexpected parser error when looking for end of macro')
+
+        if bite == opening:
+            opened += 1
+        elif bite == closing:
+            opened -= 1
+        macro += bite
+
+    if opened:
+        raise Exception('Unexpectedly met end of string when looking for end of macro')
+    return macro, string
+
+
+def consume_chars(regex, string):
+    """Consume regex matches of all characters of a string."""
+    match = regex.match(string)
+    if match:
+        end = match.end()
+        return string[0:end], string[end:]
+    else:
+        raise NoMatchExceptionError(
+            'Expected match failed (string: "%s", regex: "%s" )' % (string, regex.pattern)
+        )
+
+
+def read_boolean(string):
+    """Read boolean macros."""
+    return find_end_of_bracketed_macro(string, re_brackets['('], '(', ')')
+
+
+def matching_bracket(bracket):
+    """Find the appropriate matching brackets."""
+    if bracket == '{':
+        return '}'
+    elif bracket == '(':
+        return ')'
+    raise Exception(
+        'Undefined bracket matching - add defintion of "%s" to ' 'matching_bracket()' % bracket
+    )
+
+
+def read_macro(string):
+    """Read macro in brackets."""
+    opening = string[1]
+    closing = matching_bracket(opening)
+    return find_end_of_bracketed_macro(string, re_brackets[opening], opening, closing)
+
+
+def read_next_chunk(string):
+    """Read string chunks after operators."""
+    chunk = ''
+    chunk_type = ''
+
+    if not string:
+        return '', '', 'text'
+
+    if string[0:2] in ('>=', '<=', '=>', '=<'):
+        chunk = string[0:2]
+        chunk_type = 'operator'
+        rest = string[2:]
+
+    elif string[0:1] in ('<', '>', '='):
+        chunk = string[0:1]
+        chunk_type = 'operator'
+        rest = string[1:]
+
+    elif string[0].isspace() or string[0] == ',':
+        chunk = ''
+        chunk_type = 'space'
+        rest = consume_chars(re_spaces, string)[1]
+
+    elif string[0:2] == '%%':
+        chunk = '%%'
+        chunk_type = 'text'
+        rest = string[2:]
+
+    elif string[0:2] in ('%{', '%('):
+        chunk, rest = read_macro(string)
+        chunk_type = 'macro'
+
+    elif string[0] == '%':
+        chunk, rest = consume_chars(re_macro_unbraced, string)
+        chunk_type = 'macro'
+
+    elif string[0] == '(':
+        chunk, rest = read_boolean(string)
+        chunk_type = 'macro'
+
+    else:
+        chunk, rest = consume_chars(re_name, string)
+        chunk_type = 'text'
+
+    return (rest, chunk, chunk_type)
+
+
+class DepParserError(Exception):
+    """Exception definition for dependency parsing."""
+
+    pass
+
+
+class DependencyParser:
+    """Dependency parsing class."""
+
+    def __init__(self, line):
+        """Initialize class."""
+        # adding comma will cause flush in the end of line
+        self.string = line + ', '
+        self.parsed = []
+        self.token = []
+        self.state = 'start'
+        self.space = False
+        self.token_name = ''
+        self.token_operator = None
+        self.token_version = None
+        self.go_on = True
+        while self.go_on:
+            self.string, self.next, self.next_type = read_next_chunk(self.string)
+            logger.debug(
+                """========
+                chunk: '%s'
+                chunk_type: '%s'
+                rest: '%s'
+                token: '%s'
+                parsed: '%s'""",
+                self.next,
+                self.next_type,
+                self.string,
+                self.token,
+                self.parsed,
+            )
+            self.state_change()
+
+    def flat_out(self):
+        """Flatten versioned definition to a single string."""
+        result = []
+        for name, operator, ver in self.parsed:
+            result.append(RpmRequiresToken(name, operator, ver))
+        return result
+
+    def flush(self):
+        """Clean token variables of the class."""
+        self.parsed.append((self.token_name, self.token_operator, self.token_version))
+        # cleanup state
+        self.token = []
+        self.token_name = ''
+        self.token_operator = None
+        self.token_version = None
+        if not self.string:
+            self.go_on = False
+
+    def reconstitute_token(self):
+        """Erase token."""
+        r = ''.join(self.token)
+        logger.debug("reconstituting '%s'", r)
+        self.token = []
+        return r
+
+    def name_state_change(self):
+        """Check name of next token."""
+        if self.next_type in ['text', 'macro']:
+            if self.space:
+                logger.debug('text after space --> flush')
+                self.token_name = self.reconstitute_token()
+                self.space = False
+                self.flush()
+        elif self.next_type == 'space':
+            self.space = True
+        elif self.next_type == 'operator':
+            self.token_name = self.reconstitute_token()
+            self.state = 'operator'
+            self.space = False
+
+        self.token.append(self.next)
+
+    def operator_state_change(self):
+        """Check next operator token."""
+        if self.next_type in ['text', 'macro']:
+            self.state = 'version'
+            self.token_operator = self.reconstitute_token()
+            self.space = False
+        elif self.next_type == 'space':
+            self.space = True
+        elif self.next_type == 'operator':
+            if self.space:
+                raise DepParserError('found operator after operator')
+
+        self.token.append(self.next)
+
+    def version_state_change(self):
+        """Check valid token after version."""
+        if self.next_type == 'text':
+            pass
+        elif self.next_type == 'space':
+            self.token_version = self.reconstitute_token()
+            self.flush()
+            self.state = 'name'
+            self.space = False
+        elif self.next_type == 'macro':
+            pass
+        elif self.next_type == 'operator':
+            raise DepParserError('found operator after version')
+
+        self.token.append(self.next)
+
+    def start_state_change(self):
+        """Check next token valid for starting definition."""
+        if self.next_type == 'text':
+            self.state = 'name'
+        elif self.next_type == 'space':
+            pass
+        elif self.next_type == 'macro':
+            self.state = 'name'
+        elif self.next_type == 'operator':
+            raise DepParserError('found operator when name expected')
+
+        self.token.append(self.next)
+
+    def state_change(self):
+        """Select which state change to check."""
+        if self.state == 'name':
+            self.name_state_change()
+        elif self.state == 'operator':
+            self.operator_state_change()
+        elif self.state == 'version':
+            self.version_state_change()
+        elif self.state == 'start':
+            self.start_state_change()
+        logger.debug('new state: %s', self.state)

spec_cleaner/fileutils.py

@@ -0,0 +1,64 @@
+# vim: set ts=4 sw=4 et: coding=UTF-8
+
+import os
+import sys
+import sysconfig
+from io import StringIO
+from typing import IO
+
+from .rpmexception import RpmExceptionError
+
+
+def open_datafile(name: str) -> IO[str]:
+    """
+    Open data files.
+
+    Used all around so kept glob here for importing.
+
+    Args:
+        name: A string representing the name of the datafile to open.
+
+    Raises:
+        RpmExceptionError if the file is not found in predefined datadirs.
+    """
+    homedir = os.getenv('HOME', '~') + '/.local/'
+
+    possible_paths = (
+        '{0}/../data/{1}'.format(os.path.dirname(os.path.realpath(__file__)), name),
+        '{0}/share/spec-cleaner/{1}'.format(homedir, name),
+        '{0}/share/spec-cleaner/{1}'.format(sysconfig.get_path('data'), name),
+        '{0}/share/spec-cleaner/{1}'.format(sys.prefix, name),
+    )
+
+    for path in possible_paths:
+        try:
+            _file = open(path, mode='r')
+        except OSError:
+            pass
+        else:
+            return _file
+    # file not found
+    raise RpmExceptionError("File '{}' not found in datadirs".format(name))
+
+
+def open_stringio_spec(name: str) -> IO[str]:
+    """
+    Open regular files with exception handling.
+
+    Args:
+        name: A string with the file name.
+
+    Returns:
+        A file object.
+
+    Raises:
+        RpmExceptionError if the file is not readable.
+    """
+    data = StringIO()
+    try:
+        with open(name, mode='r') as f:
+            data.write(f.read())
+            data.seek(0, 0)
+    except (IOError, UnicodeDecodeError) as error:
+        raise RpmExceptionError(str(error))
+    return data

spec_cleaner/rpmbuild.py

@@ -0,0 +1,56 @@
+# vim: set ts=4 sw=4 et: coding=UTF-8
+
+# We basically extend rpmcheck
+from .rpmcheck import RpmCheck
+
+
+class RpmBuild(RpmCheck):
+    """A class providing methods for %build section cleaning."""
+
+    def add(self, line: str) -> None:
+        # we do not want to run suseupdateconfig, deprecated
+        if self.reg.re_suseupdateconfig.search(line):
+            return
+
+        # if user uses cmake/configure directly just recommend him using the macros
+        if not self.minimal:
+            self._comment_macro_calls(line)
+
+        RpmCheck.add(self, line)
+
+    def _comment_macro_calls(self, line: str) -> None:
+        """
+        Add a comment if the package uses direct call of build tools instead of macro.
+
+        Args:
+            line: A string representing a line to process.
+        """
+        # if the line itself is comment then we do not add any fixme on top of them
+        if self.reg.re_comment.match(line):
+            return
+        # otherwise process the fixes
+        if self.reg.re_configure.match(line):
+            msg = '# FIXME: you should use the %%configure macro'
+        elif self.reg.re_cmake.match(line):
+            msg = '# FIXME: you should use the %%cmake macros'
+        elif self.reg.re_meson.match(line):
+            msg = '# FIXME: you should use the %%meson macros'
+        elif self.reg.re_qmake5.match(line):
+            msg = '# FIXME: you should use the %%qmake5 macro'
+        else:
+            return
+
+        position = len(self.lines)
+        if self.previous_line and self.previous_line.endswith('\\'):
+            # Backtrack until we are on top of multiline command
+            for i in reversed(self.lines):
+                if i.endswith('\\'):
+                    position -= 1
+                else:
+                    # we stop backtracking on the first
+                    # non-backslashed line
+                    break
+        # Check if on the position above is no comment
+        # if not add our message
+        if not self.lines[position - 1].startswith('#'):
+            self.lines.insert(position, msg)

spec_cleaner/rpmcheck.py

@@ -0,0 +1,77 @@
+# vim: set ts=4 sw=4 et: coding=UTF-8
+
+from .rpmsection import Section
+
+
+class RpmCheck(Section):
+    """
+    A class providing methods for %check section cleaning.
+
+    Replace various troublemakers in check phase.
+    """
+
+    def add(self, line: str) -> None:
+        line = self._complete_cleanup(line)
+
+        # smp_mflags for jobs macro replacement
+        line = self.reg.re_jobs.sub('%{?_smp_mflags}', line)
+
+        if not self.minimal:
+            line = self._replace_pytest(line)
+            line = self._replace_unittest(line)
+            line = self._replace_make(line)
+
+        Section.add(self, line)
+
+    def _replace_pytest(self, line: str) -> str:
+        """
+        Replace various pytest calls with %pytest or %pytest_arch macros.
+
+        Args:
+            line: A string representing a line to process.
+
+        Return:
+            The processed line.
+        """
+        line = self.reg.re_pytest.sub('%pytest', line)
+        line = self.reg.re_pytest_arch.sub('%pytest_arch', line)
+        return line
+
+    def _replace_unittest(self, line: str) -> str:
+        """
+        Replace various pytest calls with %pyunittest or %pyunittest_arch macros.
+
+        Args:
+            line: A string representing a line to process.
+
+        Return:
+            The processed line.
+        """
+        line = self.reg.re_pyunittest.sub('%pyunittest', line)
+        line = self.reg.re_pyunittest_arch.sub('%pyunittest_arch', line)
+        return line
+
+    def _replace_make(self, line: str) -> str:
+        """
+        Replace 'make' call with '%make_build' macro.
+
+        Args:
+            line: A string representing a line to process.
+
+        Return:
+            The processed line.
+        """
+        # if it is comment line then do nothing
+        if line.lstrip().startswith('#'):
+            return line
+        # find all make calls and replace them with %make_build
+        if self.reg.re_make.match(line):
+            line = self.reg.re_make.sub(r'\1%make_build\2', line)
+        # remove from line all the options that are part of %make_build macro
+        if self.reg.re_make_build.match(line):
+            # remove smp flags
+            line = line.replace(' %{?_smp_mflags}', '')
+            # remove verbosity
+            line = line.replace(' V=1', '')
+            line = line.replace(' VERBOSE=1', '')
+        return line