coalib.parsing.parse_cli() - Code Metrics - Inspection of "LocalBearTestHelper revamp" - coala-analyzer/coala - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#1371)

by Abdeali

created 2016-02-10 05:27 UTC

coalib.parsing.parse_cli() C

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	7
dl	0
loc	57
rs	6.6397

How to fix Long Method

from collections import OrderedDict
import os
import sys

from coalib.parsing.LineParser import LineParser
from coalib.settings.Section import Section, append_to_sections
from coalib.parsing.DefaultArgParser import default_arg_parser


def parse_cli(arg_list=None,
              origin=os.getcwd(),
              arg_parser=None,
              key_value_delimiters=('=', ':'),
              comment_seperators=(),
              key_delimiters=(',',),
              section_override_delimiters=(".",)):
    """
    Parses the CLI arguments and creates sections out of it.

    :param arg_list:                    The CLI argument list.
    :param origin:                      Directory used to interpret relative
                                        paths given as argument.
    :param arg_parser:                  Instance of ArgParser that is used to
                                        parse none-setting arguments.
    :param key_value_delimiters:        Delimiters to separate key and value
                                        in setting arguments.
    :param comment_seperators:          Allowed prefixes for comments.
    :param key_delimiters:              Delimiter to separate multiple keys of
                                        a setting argument.
    :param section_override_delimiters: The delimiter to delimit the section
                                        from the key name (e.g. the '.' in
                                        sect.key = value).
    :return:                            A dictionary holding section names
                                        as keys and the sections themselves
                                        as value.
    """
    # Note: arg_list can also be []. Hence we cannot use
    # `arg_list = arg_list or default_list`
    arg_list = sys.argv[1:] if arg_list is None else arg_list
    arg_parser = arg_parser or default_arg_parser()
    origin += os.path.sep
    sections = OrderedDict(default=Section('Default'))
    line_parser = LineParser(key_value_delimiters,
                             comment_seperators,
                             key_delimiters,
                             {},
                             section_override_delimiters)

    for arg_key, arg_value in sorted(
            vars(arg_parser.parse_args(arg_list)).items()):
        if arg_key == 'settings' and arg_value is not None:
            parse_custom_settings(sections,
                                  arg_value,
                                  origin,
                                  line_parser)
        else:
            if isinstance(arg_value, list):
                arg_value = ",".join([str(val) for val in arg_value])

            append_to_sections(sections,
                               arg_key,
                               arg_value,
                               origin,
                               from_cli=True)

    return sections


def parse_custom_settings(sections,
                          custom_settings_list,
                          origin,
                          line_parser):
    """
    Parses the custom settings given to coala via `-S something=value`.

    :param sections:             The Section dictionary to add to (mutable).
    :param custom_settings_list: The list of settings strings.
    :param origin:               The originating directory.
    :param line_parser:          The LineParser to use.
    """
    for setting_definition in custom_settings_list:
        (dummy,
         key_touples,
         value,
         dummy) = line_parser.parse(setting_definition)
        for key_touple in key_touples:
            append_to_sections(sections,
                               key=key_touple[1],
                               value=value,
                               origin=origin,
                               section_name=key_touple[0],
                               from_cli=True)


1			from collections import OrderedDict
2			import os
3			import sys
4
5			from coalib.parsing.LineParser import LineParser
6			from coalib.settings.Section import Section, append_to_sections
7			from coalib.parsing.DefaultArgParser import default_arg_parser
8
9
10			def parse_cli(arg_list=None,
11			origin=os.getcwd(),
12			arg_parser=None,
13			key_value_delimiters=('=', ':'),
14			comment_seperators=(),
15			key_delimiters=(',',),
16			section_override_delimiters=(".",)):
17			"""
18			Parses the CLI arguments and creates sections out of it.
19
20			:param arg_list: The CLI argument list.
21			:param origin: Directory used to interpret relative
22			paths given as argument.
23			:param arg_parser: Instance of ArgParser that is used to
24			parse none-setting arguments.
25			:param key_value_delimiters: Delimiters to separate key and value
26			in setting arguments.
27			:param comment_seperators: Allowed prefixes for comments.
28			:param key_delimiters: Delimiter to separate multiple keys of
29			a setting argument.
30			:param section_override_delimiters: The delimiter to delimit the section
31			from the key name (e.g. the '.' in
32			sect.key = value).
33			:return: A dictionary holding section names
34			as keys and the sections themselves
35			as value.
36			"""
37			# Note: arg_list can also be []. Hence we cannot use
38			# `arg_list = arg_list or default_list`
39			arg_list = sys.argv[1:] if arg_list is None else arg_list
40			arg_parser = arg_parser or default_arg_parser()
41			origin += os.path.sep
42			sections = OrderedDict(default=Section('Default'))
43			line_parser = LineParser(key_value_delimiters,
44			comment_seperators,
45			key_delimiters,
46			{},
47			section_override_delimiters)
48
49			for arg_key, arg_value in sorted(
50			vars(arg_parser.parse_args(arg_list)).items()):
51			if arg_key == 'settings' and arg_value is not None:
52			parse_custom_settings(sections,
53			arg_value,
54			origin,
55			line_parser)
56			else:
57			if isinstance(arg_value, list):
58			arg_value = ",".join([str(val) for val in arg_value])
59
60			append_to_sections(sections,
61			arg_key,
62			arg_value,
63			origin,
64			from_cli=True)
65
66			return sections
67
68
69			def parse_custom_settings(sections,
70			custom_settings_list,
71			origin,
72			line_parser):
73			"""
74			Parses the custom settings given to coala via `-S something=value`.
75
76			:param sections: The Section dictionary to add to (mutable).
77			:param custom_settings_list: The list of settings strings.
78			:param origin: The originating directory.
79			:param line_parser: The LineParser to use.
80			"""
81			for setting_definition in custom_settings_list:
82			(dummy,
83			key_touples,
84			value,
85			dummy) = line_parser.parse(setting_definition)
86			for key_touple in key_touples:
87			append_to_sections(sections,
88			key=key_touple[1],
89			value=value,
90			origin=origin,
91			section_name=key_touple[0],
92			from_cli=True)
93

coala-analyzer / coala

Pull Request — master (#1371)

coalib.parsing.parse_cli() C

Complexity

Size

Duplication

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like