fastest.code_assets.naive_case_detector.stack_imports() - Code Metrics - Inspection of "Merge pull request #17 from AmreshVenugopal/refact..." - AmreshVenugopal/fastest - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( db2bdb...52f8b4 )

by Amresh

created 2019-01-24 23:41 UTC

A

↳ Parent: fastest.code_assets.naive_case_detector.format_imports()

Complexity

Conditions

Size

Total Lines	17
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	5
dl	0
loc	17
rs	10
c	0
b	0
f	0
cc	1
nop	1

import re
from fastest.constants import Keys, Patterns


FUNCTION_CALL = 0
OUTPUT = 1


def format_imports(import_statements):
    """
    -----
    examples:
    @need
    from fastest.constants import TestBodies
    @end

    @let
    input = TestBodies.TEST_STACK_IMPORTS_INPUT
    output = TestBodies.TEST_STACK_IMPORTS_OUTPUT
    @end
    1) format_imports(input) -> output
    -----
    :param import_statements: list
    :return: list
    """
    return [
        '{}\n'.format(import_statement.strip())
        for import_statement in import_statements
        if len(import_statement) > 0
    ]


def get_imports_from_docstring(example_passage):
    """
    ----
    examples:

    @need
    from fastest.constants import TestBodies
    @end

    @let
    example_passage = TestBodies.EXAMPLE_WITH_IMPORTS
    import_statements = TestBodies.TEST_IMPORT_EXTRACTION
    empty_example_passage = ''
    @end

    1) get_imports_from_docstring(example_passage) -> import_statements
    1) get_imports_from_docstring(empty_example_passage) -> []
    ----
    :param example_passage: str
    :return: list
    """
    needed_imports = re.findall(Patterns.NEED_IMPORT, example_passage, re.M)
    needed_imports = needed_imports if len(needed_imports) > 0 else None
    if needed_imports is None:
        return []

    needed_imports = ''.join(needed_imports).replace(Patterns.IMPORT_DEC, '').split('\n')
    return format_imports(needed_imports)


def get_variables_from_docstring(example_passage):
    """
    ----
    examples:
    @need
    from fastest.constants import TestBodies
    @end

    @let
    example_passage = TestBodies.TEST_VARIABLES_FROM_DOCSTRING
    empty_example_passage = ''
    expected_output = TestBodies.TEST_VARIABLES_FROM_DOCSTRING_RESULT
    @end

    1) get_variables_from_docstring(empty_example_passage) -> ''
    2) get_variables_from_docstring(example_passage) -> expected_output
    ----
    :param example_passage: str
    :return: list
    """
    needed_variables = re.findall(Patterns.NEEDED_VARIABLES, example_passage)
    if len(needed_variables) == 0:
        return ''
    needed_variables = needed_variables[0]
    needed_variables = needed_variables.replace('@let', '')
    return needed_variables.split('\n')


def stack_examples(examples_strings):
    """
    ----
    examples:

    @need
    from fastest.constants import TestBodies
    @end

    @let
    example_strings = TestBodies.STACK_EXAMPLES_TEST
    @end

    1) stack_examples('') -> []
    2) stack_examples(example_strings) -> [{'expect': '25', 'from': 'square(5)'}]
    ----
    :param examples_strings: list
    :return: list
    """
    example_stack = []
    for example in examples_strings:
        test_function, expectation = re.sub(Patterns.NUMBER_BULLET, '', example, 1)\
            .rsplit(Patterns.TEST_SEP, 1)

        example_stack.append({
            Keys.FROM: test_function,
            Keys.EXPECT: expectation
        })
    return example_stack


def get_params_from_docstring(statements):
    """
    ----
    examples:

    @need
    from fastest.constants import TestBodies
    @end

    @let
    statements = TestBodies.GET_PARAMS_FROM_DOCSTRING_TEST
    @end

    1) get_params_from_docstring('') -> []
    2) get_params_from_docstring(statements) -> TestBodies.EXPECT_PARAMS
    ----
    :param statements: str
    :return: list
    """
    params = re.findall(r':param .*:(.*)', statements)
    return [
        param.replace(' ', '')
        for param in params
    ]


def get_return_from_docstring(statements):
    """
    ----
    examples:
    @need
    from fastest.constants import TestBodies
    @end

    @let
    statements = TestBodies.RETURN_TYPE_TEST
    @end

    1) get_return_from_docstring('') -> None
    2) get_return_from_docstring(statements) -> 'int'
    ----
    :param statements: str
    :return: str
    """
    return_statement = re.search(r':return: (.*)', statements)
    return return_statement.group(1) if return_statement is not None else None


def get_test_case_examples(example_passage):
    """
    ----
    examples:

    @need
    from fastest.constants import TestBodies
    @end

    @let
    example_passage = TestBodies.TEST_EXAMPLE_PASSAGE
    @end

    1) get_test_case_examples(example_passage) -> TestBodies.TEST_EXAMPLE_PASSAGE_RESULT
    ----
    :param example_passage: str
    :return: list
    """
    examples_strings = re.findall(Patterns.TEST_CASE_EXAMPLE, example_passage, re.M)
    examples_strings = examples_strings if len(examples_strings) > 0 else []
    return stack_examples(examples_strings)


def get_test_from_example_passage(statements):
    """
    ----
    examples:

    @need
    from fastest.constants import TestBodies
    @end

    @let
    statements = TestBodies.NAIVE_CASE_TEST_STATEMENT
    @end

    1) get_test_from_example_passage(statements) -> TestBodies.NAIVE_CASE_TEST_RESULT
    2) get_test_from_example_passage(None) -> None
    3) get_test_from_example_passage('lorem ipsum') -> None
    ----
    :param statements:
    :return:
    """
    if statements is None:
        return None

    example_passage = re.findall(Patterns.EXAMPLE_PASSAGE, statements, re.I)
    example_passage = example_passage[0] if len(example_passage) > 0 else None
    if example_passage is None:
        return None
    import_statements = get_imports_from_docstring(example_passage)
    variables = get_variables_from_docstring(example_passage)
    examples = get_test_case_examples(example_passage)
    params = get_params_from_docstring(statements)
    return_statement = get_return_from_docstring(statements)

    return None \
        if examples is None \
        else {
            Keys.IMPORTS: import_statements,
            Keys.VARIABLES: variables,
            Keys.EXAMPLES: examples,
            Keys.PARAMS: params,
            Keys.RETURN: return_statement
        }


1			import re
2			from fastest.constants import Keys, Patterns
3
4
5			FUNCTION_CALL = 0
6			OUTPUT = 1
7
8
9			def format_imports(import_statements):
10			"""
11			-----
12			examples:
13			@need
14			from fastest.constants import TestBodies
15			@end
16
17			@let
18			input = TestBodies.TEST_STACK_IMPORTS_INPUT
19			output = TestBodies.TEST_STACK_IMPORTS_OUTPUT
20			@end
21			1) format_imports(input) -> output
22			-----
23			:param import_statements: list
24			:return: list
25			"""
26			return [
27			'{}\n'.format(import_statement.strip())
28			for import_statement in import_statements
29			if len(import_statement) > 0
30			]
31
32
33			def get_imports_from_docstring(example_passage):
34			"""
35			----
36			examples:
37
38			@need
39			from fastest.constants import TestBodies
40			@end
41
42			@let
43			example_passage = TestBodies.EXAMPLE_WITH_IMPORTS
44			import_statements = TestBodies.TEST_IMPORT_EXTRACTION
45			empty_example_passage = ''
46			@end
47
48			1) get_imports_from_docstring(example_passage) -> import_statements
49			1) get_imports_from_docstring(empty_example_passage) -> []
50			----
51			:param example_passage: str
52			:return: list
53			"""
54			needed_imports = re.findall(Patterns.NEED_IMPORT, example_passage, re.M)
55			needed_imports = needed_imports if len(needed_imports) > 0 else None
56			if needed_imports is None:
57			return []
58
59			needed_imports = ''.join(needed_imports).replace(Patterns.IMPORT_DEC, '').split('\n')
60			return format_imports(needed_imports)
61
62
63			def get_variables_from_docstring(example_passage):
64			"""
65			----
66			examples:
67			@need
68			from fastest.constants import TestBodies
69			@end
70
71			@let
72			example_passage = TestBodies.TEST_VARIABLES_FROM_DOCSTRING
73			empty_example_passage = ''
74			expected_output = TestBodies.TEST_VARIABLES_FROM_DOCSTRING_RESULT
75			@end
76
77			1) get_variables_from_docstring(empty_example_passage) -> ''
78			2) get_variables_from_docstring(example_passage) -> expected_output
79			----
80			:param example_passage: str
81			:return: list
82			"""
83			needed_variables = re.findall(Patterns.NEEDED_VARIABLES, example_passage)
84			if len(needed_variables) == 0:
85			return ''
86			needed_variables = needed_variables[0]
87			needed_variables = needed_variables.replace('@let', '')
88			return needed_variables.split('\n')
89
90
91			def stack_examples(examples_strings):
92			"""
93			----
94			examples:
95
96			@need
97			from fastest.constants import TestBodies
98			@end
99
100			@let
101			example_strings = TestBodies.STACK_EXAMPLES_TEST
102			@end
103
104			1) stack_examples('') -> []
105			2) stack_examples(example_strings) -> [{'expect': '25', 'from': 'square(5)'}]
106			----
107			:param examples_strings: list
108			:return: list
109			"""
110			example_stack = []
111			for example in examples_strings:
112			test_function, expectation = re.sub(Patterns.NUMBER_BULLET, '', example, 1)\
113			.rsplit(Patterns.TEST_SEP, 1)
114
115			example_stack.append({
116			Keys.FROM: test_function,
117			Keys.EXPECT: expectation
118			})
119			return example_stack
120
121
122			def get_params_from_docstring(statements):
123			"""
124			----
125			examples:
126
127			@need
128			from fastest.constants import TestBodies
129			@end
130
131			@let
132			statements = TestBodies.GET_PARAMS_FROM_DOCSTRING_TEST
133			@end
134
135			1) get_params_from_docstring('') -> []
136			2) get_params_from_docstring(statements) -> TestBodies.EXPECT_PARAMS
137			----
138			:param statements: str
139			:return: list
140			"""
141			params = re.findall(r':param .:(.)', statements)
142			return [
143			param.replace(' ', '')
144			for param in params
145			]
146
147
148			def get_return_from_docstring(statements):
149			"""
150			----
151			examples:
152			@need
153			from fastest.constants import TestBodies
154			@end
155
156			@let
157			statements = TestBodies.RETURN_TYPE_TEST
158			@end
159
160			1) get_return_from_docstring('') -> None
161			2) get_return_from_docstring(statements) -> 'int'
162			----
163			:param statements: str
164			:return: str
165			"""
166			return_statement = re.search(r':return: (.*)', statements)
167			return return_statement.group(1) if return_statement is not None else None
168
169
170			def get_test_case_examples(example_passage):
171			"""
172			----
173			examples:
174
175			@need
176			from fastest.constants import TestBodies
177			@end
178
179			@let
180			example_passage = TestBodies.TEST_EXAMPLE_PASSAGE
181			@end
182
183			1) get_test_case_examples(example_passage) -> TestBodies.TEST_EXAMPLE_PASSAGE_RESULT
184			----
185			:param example_passage: str
186			:return: list
187			"""
188			examples_strings = re.findall(Patterns.TEST_CASE_EXAMPLE, example_passage, re.M)
189			examples_strings = examples_strings if len(examples_strings) > 0 else []
190			return stack_examples(examples_strings)
191
192
193			def get_test_from_example_passage(statements):
194			"""
195			----
196			examples:
197
198			@need
199			from fastest.constants import TestBodies
200			@end
201
202			@let
203			statements = TestBodies.NAIVE_CASE_TEST_STATEMENT
204			@end
205
206			1) get_test_from_example_passage(statements) -> TestBodies.NAIVE_CASE_TEST_RESULT
207			2) get_test_from_example_passage(None) -> None
208			3) get_test_from_example_passage('lorem ipsum') -> None
209			----
210			:param statements:
211			:return:
212			"""
213			if statements is None:
214			return None
215
216			example_passage = re.findall(Patterns.EXAMPLE_PASSAGE, statements, re.I)
217			example_passage = example_passage[0] if len(example_passage) > 0 else None
218			if example_passage is None:
219			return None
220			import_statements = get_imports_from_docstring(example_passage)
221			variables = get_variables_from_docstring(example_passage)
222			examples = get_test_case_examples(example_passage)
223			params = get_params_from_docstring(statements)
224			return_statement = get_return_from_docstring(statements)
225
226			return None \
227			if examples is None \
228			else {
229			Keys.IMPORTS: import_statements,
230			Keys.VARIABLES: variables,
231			Keys.EXAMPLES: examples,
232			Keys.PARAMS: params,
233			Keys.RETURN: return_statement
234			}
235

AmreshVenugopal / fastest

Push — master ( db2bdb...52f8b4 )

A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like