coalib.parsing package

Subpackages

• coalib.parsing.filters package
  • Submodules
  • coalib.parsing.filters.CanDetectFilter module
  • coalib.parsing.filters.CanFixFilter module
  • coalib.parsing.filters.LanguageFilter module
  • Module contents

Submodules

coalib.parsing.CliParsing module

coalib.parsing.CliParsing.check_conflicts(sections)

Checks if there are any conflicting arguments passed.

Parameters:sections – The {section_name: section_object} dictionary to check conflicts for. Returns:True if no conflicts occur. Raises:SystemExit – If there are conflicting arguments (exit code: 2)

coalib.parsing.CliParsing.parse_cli(arg_list=None, origin='/home/docs/checkouts/readthedocs.org/user_builds/coala-api/checkouts/latest/docs', arg_parser=None, args=None, key_value_delimiters=('=', ':'), comment_seperators=(), key_delimiters=(', ', ), section_override_delimiters=('.', ), key_value_append_delimiters=('+=', ))

Parses the CLI arguments and creates sections out of it.

Parameters:

• arg_list – The CLI argument list.
• origin – Directory used to interpret relative paths given as argument.
• arg_parser – Instance of ArgParser that is used to parse none-setting arguments.
• args – Alternative pre-parsed CLI arguments.
• key_value_delimiters – Delimiters to separate key and value in setting arguments where settings are being defined.
• comment_seperators – Allowed prefixes for comments.
• key_delimiters – Delimiter to separate multiple keys of a setting argument.
• section_override_delimiters – The delimiter to delimit the section from the key name (e.g. the ‘.’ in sect.key = value).
• key_value_append_delimiters – Delimiters to separate key and value in setting arguments where settings are being appended.

Returns:

A dictionary holding section names as keys and the sections themselves as value.

coalib.parsing.CliParsing.parse_custom_settings(sections, custom_settings_list, origin, line_parser)

Parses the custom settings given to coala via -S something=value.

Parameters:

• sections – The Section dictionary to add to (mutable).
• custom_settings_list – The list of settings strings.
• origin – The originating directory.
• line_parser – The LineParser to use.

coalib.parsing.ConfParser module

class coalib.parsing.ConfParser.ConfParser(key_value_delimiters=('=', ), comment_seperators=('#', ), key_delimiters=(', ', ' '), section_name_surroundings=mappingproxy({'[': ']'}), remove_empty_iter_elements=True, key_value_append_delimiters=('+=', ))

Bases: object

get_section(name, create_if_not_exists=False)

parse(input_data, overwrite=False)

Parses the input and adds the new data to the existing.

Parameters:

• input_data – The filename to parse from.
• overwrite – If True, wipes all existing Settings inside this instance and adds only the newly parsed ones. If False, adds the newly parsed data to the existing one (and overwrites already existing keys with the newly parsed values).

Returns:

A dictionary with (lowercase) section names as keys and their Setting objects as values.

coalib.parsing.DefaultArgParser module

class coalib.parsing.DefaultArgParser.CustomFormatter(prog, indent_increment=2, max_help_position=24, width=None)

Bases: argparse.RawDescriptionHelpFormatter

A Custom Formatter that will keep the metavars in the usage but remove them in the more detailed arguments section.

class coalib.parsing.DefaultArgParser.PathArg

Bases: str

Uni(xi)fying OS-native directory separators in path arguments.

Removing the pain from interactively using coala in a Windows cmdline, because backslashes are interpreted as escaping syntax and therefore removed when arguments are turned into coala settings

>>> import os
>>> PathArg(os.path.join('path', 'with', 'separators'))
'path/with/separators'

coalib.parsing.DefaultArgParser.default_arg_parser(formatter_class=None)

This function creates an ArgParser to parse command line arguments.

Parameters:formatter_class – Formatting the arg_parser output into a specific form. For example: In the manpage format.

coalib.parsing.FilterHelper module

coalib.parsing.FilterHelper.apply_filter(filter_name, filter_args, all_bears=None)

Returns bears after filtering based on filter_args. It returns all bears if nothing is present in filter_args.

Parameters:

• filter_name – Name of the filter.
• filter_args – Arguments of the filter to be passed in. For example: ['c', 'java']
• all_bears – List of bears on which filter is to be applied. All the bears are loaded automatically by default.

Returns:

Filtered bears based on a single filter.

coalib.parsing.FilterHelper.apply_filters(filters, bears=None)

Returns bears after filtering based on filters. It returns intersection of bears if more than one element is present in filters list.

Parameters:

• filters – List of args based on bears has to be filtered. For example: [['language', 'c', 'java'], ['can_fix', 'syntax']]
• bears – The bears to filter.

Returns:

Filtered bears.

coalib.parsing.FilterHelper.is_valid_filter(filter)

coalib.parsing.Globbing module

coalib.parsing.Globbing.fnmatch(name, globs)

Tests whether name matches one of the given globs.

An empty glob will match nothing and return false.

Parameters:

• name – File or directory name
• globs – Glob string with wildcards or list of globs

Returns:

Boolean: Whether or not name is matched by glob

Glob Syntax:

• ‘[seq]’: Matches any character in seq. Cannot be empty. Any

  special character looses its special meaning in a set.

• ‘[!seq]’: Matches any character not in seq. Cannot be empty. Any

  special character looses its special meaning in a set.

• ‘(seq_a|seq_b)’: Matches either sequence_a or sequence_b as a whole.

  More than two or just one sequence can be given.

• ‘?’: Matches any single character.
• ‘*’: Matches everything but os.sep.
• ‘**’: Matches everything.

coalib.parsing.Globbing.glob(pattern)

Iterates all filesystem paths that get matched by the glob pattern. Syntax is equal to that of fnmatch.

Parameters:pattern – Glob pattern with wildcards Returns:List of all file names that match pattern

coalib.parsing.Globbing.glob_escape(input_string)

Escapes the given string with [c] pattern. Examples:

>>> from coalib.parsing.Globbing import glob_escape
>>> glob_escape('test (1)')
'test [(]1[)]'
>>> glob_escape('test folder?')
'test folder[?]'
>>> glob_escape('test*folder')
'test[*]folder'

Parameters:input_string – String that is to be escaped with [ ]. Returns:Escaped string in which all the special glob characters ()[]|?* are escaped.

coalib.parsing.Globbing.has_wildcard(pattern)

Checks whether pattern has any wildcards.

Parameters:pattern – Glob pattern that may contain wildcards Returns:Boolean: Whether or not there are wildcards in pattern

coalib.parsing.Globbing.iglob(pattern)

Iterates all filesystem paths that get matched by the glob pattern. Syntax is equal to that of fnmatch.

Parameters:pattern – Glob pattern with wildcards Returns:Iterator that yields all file names that match pattern

coalib.parsing.Globbing.relative_flat_glob(dirname, basename)

Non-recursive glob for one directory. Does not accept wildcards.

Parameters:

• dirname – Directory name
• basename – Basename of a file in dir of dirname

Returns:

List containing Basename if the file exists

coalib.parsing.Globbing.relative_recursive_glob(dirname, pattern)

Recursive Glob for one directory and all its (nested) subdirectories. Accepts only ‘**’ as pattern.

Parameters:

• dirname – Directory name
• pattern – The recursive wildcard ‘**’

Returns:

Iterator that yields all the (nested) subdirectories of the given dir

coalib.parsing.Globbing.relative_wildcard_glob(dirname, pattern)

Non-recursive glob for one directory. Accepts wildcards.

Parameters:

• dirname – Directory name
• pattern – Glob pattern with wildcards

Returns:

List of files in the dir of dirname that match the pattern

coalib.parsing.Globbing.translate(pattern)

Translates a pattern into a regular expression.

Parameters:pattern – Glob pattern with wildcards Returns:Regular expression with the same meaning

coalib.parsing.InvalidFilterException module

exception coalib.parsing.InvalidFilterException.InvalidFilterException(filter_name)

Bases: LookupError

coalib.parsing.LineParser module

class coalib.parsing.LineParser.LineParser(key_value_delimiters=('=', ), comment_separators=('#', ), key_delimiters=(', ', ' '), section_name_surroundings=None, section_override_delimiters=('.', ), key_value_append_delimiters=('+=', ))

Bases: object

parse(line)

Note that every value in the returned tuple besides the value is unescaped. This is so since the value is meant to be put into a Setting later thus the escapes may be needed there.

Parameters:line – The line to parse. Returns:section_name (empty string if it’s no section name), [(section_override, key), …], value, comment

Module contents

The StringProcessing module contains various functions for extracting information out of strings.

Most of them support regexes for advanced pattern matching.