7531125911

Committed 15 Jan 2024 03:41PM UTC coverage: 99.901% (-0.07%) from 99.968%

Build # 7531125911

Build Type

Pull #125

github

Committed by

web-flow

Commit Message

Merge 1095aec08 into 131da6a81

Pull Request Pull Request #125: Pathlib everywhere

Run Details

500 of 501 branches covered (0.0%)

Branch coverage included in aggregate %.

212 of 214 new or added lines in 18 files covered. (99.07%)

1 existing line in 1 file now uncovered.

2520 of 2522 relevant lines covered (99.92%)

4.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.47

/z3c/dependencychecker/modules.py

import ast
import fnmatch
import logging
import os
import re
from xml.etree import ElementTree

from z3c.dependencychecker.dotted_name import DottedName

TEST_REGEX = r"""
{0}    # Needs to start with the path separator
\w*    # There could be some characters (or none)
test   # has to contain test on it
s?     # ensure plurals are handled as well
(      # Needs to end with either a path or a file extension:
{0}    # path separator
|      # OR
\w*    # some possible characters
\.     # a dot
\w+    # extension
)
""".format(
    os.sep
)

TEST_IN_PATH_REGEX = re.compile(TEST_REGEX, re.VERBOSE)

logger = logging.getLogger(__name__)

FOLDERS_TO_IGNORE = ("node_modules", "__pycache__", "venv")


class BaseModule:
    def __init__(self, package_path, full_path):
        self.path = full_path
        self._relative_path = self._get_relative_path(package_path, full_path)
        self.testing = self._is_test_module()

    @staticmethod
    def _get_relative_path(package_path, full_path):
        return str(full_path)[len(str(package_path)) :]

    def _is_test_module(self):
        return bool(re.search(TEST_IN_PATH_REGEX, self._relative_path))

    @classmethod
    def create_from_files(cls, top_dir):
        raise NotImplementedError

    def scan(self):
        raise NotImplementedError

    def walk_and_filter_folder(folder):
        for path, folders, filenames in os.walk(folder):
            # ignore known folder names
            folders[:] = [d for d in folders if d not in FOLDERS_TO_IGNORE]
            # ignore all folders that start with a dot
            folders[:] = fnmatch.filter(folders, "[!.]*")
            for filename in filenames:
                yield path, filename


class PythonModule(BaseModule):
    @classmethod
    def create_from_files(cls, top_dir):
        """Find all python files in the package

        For that it gets the path to where top_level.txt points to,
        which is not always a folder:
        - folder example: z3c.dependencychecker itself
        - file example: flake8-isort or any other single file distribution

        Return this very same class, which would allow to call the scan()
        method to get an iterator over all this file's imports.
        """
        if top_dir.suffix == ".py":
            yield cls(top_dir, top_dir)
            return

        for path, filename in cls.walk_and_filter_folder(top_dir):
            if filename.endswith(".py"):
                yield cls(
                    top_dir,
                    os.path.join(path, filename),
                )

    def scan(self):
        for node in ast.walk(self._get_tree()):
            yield from self._process_ast_node(node)

    def _get_tree(self):
        with open(self.path) as module_file:
            source_text = module_file.read()
        tree = ast.parse(source_text)
        return tree

    def _process_ast_node(self, node):
        if isinstance(node, ast.Import):
            for name in node.names:
                dotted_name = name.name
                yield DottedName(
                    dotted_name,
                    file_path=self.path,
                    is_test=self.testing,
                )

        elif isinstance(node, ast.ImportFrom):
            if self._is_relative_import(node):
                return
            for name in node.names:
                if name.name == "*":
                    dotted_name = node.module
                else:
                    dotted_name = f"{node.module}.{name.name}"
                yield DottedName(
                    dotted_name,
                    file_path=self.path,
                    is_test=self.testing,
                )

    @staticmethod
    def _is_relative_import(import_node):
        return import_node.level > 0


class ZCMLFile(BaseModule):
    """Extract imports from .zcml files

    These files are in common use in Zope/Plone based projects to define its
    components and more.
    """

    ELEMENTS = {
        "include": ("package",),
        "adapter": ("for", "factory", "provides"),
        "utility": ("provides", "component"),
        "browser:page": ("class", "for", "layer"),
        "subscriber": ("handler", "for"),
        "securityPolicy": ("component",),
        "genericsetup:registerProfile": ("provides",),
        "implements": ("interface",),
    }

    @classmethod
    def create_from_files(cls, top_dir):
        """Find all ZCML files in the package

        Return this very same class, which would allow to call the scan()
        method to get an iterator over all this file's imports.
        """
        if top_dir.suffix == ".py":
            return

        for path, filename in cls.walk_and_filter_folder(top_dir):
            if filename.endswith(".zcml"):
                yield cls(
                    top_dir,
                    os.path.join(path, filename),
                )

    def scan(self):
        tree = ElementTree.parse(self.path).getroot()

        for element in self.ELEMENTS:
            element_namespaced = self._build_namespaced_element(element)
            for node in tree.iter(element_namespaced):
                for attrib in self.ELEMENTS[element]:
                    yield from self._extract_dotted_name(node, attrib)

    def _extract_dotted_name(self, node, attr):
        if attr in node.keys():
            candidate_text = node.get(attr)
            for dotted_name in candidate_text.split(" "):
                if not dotted_name or dotted_name.startswith("."):
                    continue

                if dotted_name == "*":
                    continue

                yield DottedName(
                    dotted_name,
                    file_path=self.path,
                    is_test=self.testing,
                )

    @staticmethod
    def _build_namespaced_element(element):
        if ":" in element:
            namespace, name = element.split(":")
            return "{{http://namespaces.zope.org/{0}}}{1}".format(
                namespace,
                name,
            )

        return f"{{http://namespaces.zope.org/zope}}{element}"


class FTIFile(BaseModule):
    """Extract imports from Factory Type Information files

    These are xml files, usually located inside a types folder and used by
    Zope/Plone based projects to define its content types.
    """

    TYPES_FOLDER = f"{os.sep}types"

    @classmethod
    def create_from_files(cls, top_dir):
        """Find all FTI files, which are xml, in the package

        Return this very same class, which would allow to call the scan()
        method to get an iterator over all this file's imports.
        """
        if top_dir.suffix == ".py":
            return

        for path, filename in cls.walk_and_filter_folder(top_dir):
            if filename.endswith(".xml") and cls.TYPES_FOLDER in path:
                yield cls(
                    top_dir,
                    os.path.join(path, filename),
                )

    def scan(self):
        tree = ElementTree.parse(self.path).getroot()

        for node in tree.iter("property"):
            if "name" in node.keys():
                name = node.get("name")
                if name in ("klass", "schema"):
                    if node.text:
                        yield DottedName(
                            node.text.strip(),
                            file_path=self.path,
                            is_test=self.testing,
                        )


class GSMetadata(BaseModule):
    """Extract imports from Generic Setup metadata.xml files

    These files are in common use in Zope/Plone to define Generic Setup
    profile dependencies between projects.
    """

    PROFILE_RE = re.compile(r"profile-(?P<dotted_name>[\w.]+):[\w\W]+")

    @classmethod
    def create_from_files(cls, top_dir):
        """Find all metadata.xml files in the package

        Return this very same class, which would allow to call the scan()
        method to get an iterator over all this file's imports.
        """
        if top_dir.suffix == ".py":
            return

        for path, filename in cls.walk_and_filter_folder(top_dir):
            if filename == "metadata.xml":
                yield cls(
                    top_dir,
                    os.path.join(path, filename),
                )

    def scan(self):
        tree = ElementTree.parse(self.path).getroot()

        for node in tree.iter("dependency"):
            if not node.text:
                continue
            result = self.PROFILE_RE.search(node.text.strip())
            if result:
                yield DottedName(
                    result.group("dotted_name"),
                    file_path=self.path,
                    is_test=self.testing,
                )


class PythonDocstrings(PythonModule):
    """Extract imports from docstrings found inside python modules

    There are some projects that rather than having separate files to keep the
    tests, they add the inline with the code as docstrings,
    either at class or method/function level.
    """

    NODES_WITH_DOCSTRINGS = (
        ast.Module,
        ast.ClassDef,
        ast.FunctionDef,
    )

    def scan(self):
        for node in ast.walk(self._get_tree()):
            if isinstance(node, self.NODES_WITH_DOCSTRINGS):
                docstring = ast.get_docstring(node)
                yield from self._parse_docstring(docstring)

    def _parse_docstring(self, docstring):
        if not docstring:
            return

        for line in docstring.split("\n"):
            code = self._extract_code(line)
            if code:
                try:
                    tree = ast.parse(code)
                except SyntaxError:
                    logger.debug(
                        'Could not parse "%s" in %s',
                        line,
                        self.path,
                    )
                    continue

                for node in ast.walk(tree):
                    for dotted_name in self._process_ast_node(node):
                        dotted_name.is_test = True
                        yield dotted_name

    @staticmethod
    def _extract_code(line):
        if ">>>" in line:
            position = line.find(">>>") + 3
            return line[position:].strip()


class DocFiles(PythonDocstrings):
    """Extract imports from documentation-like documents

    One extended testing pattern (at least in Zope/Plone based projects) is to
    write documentation in txt/rst files that contain tests to assert that
    documentation.
    """

    @classmethod
    def create_from_files(cls, top_dir):
        """Find all documentation files in the package

        For that it gets the path to where top_level.txt points to,
        which is not always a folder:
        - folder example: z3c.dependencychecker itself
        - file example: flake8-isort or any other single file distribution

        Return this very same class, which would allow to call the scan()
        method to get an iterator over all this file's imports.
        """
        if top_dir.suffix == ".py":
            return

        for path, filename in cls.walk_and_filter_folder(top_dir):
            if filename.endswith(".txt") or filename.endswith(".rst"):
                yield cls(
                    top_dir,
                    os.path.join(path, filename),
                )

    def scan(self):
        try:
            yield from self._scan()
        except UnicodeDecodeError:
            logger.error("Unicode Problems parsing %s", self.path)

    def _scan(self):
        with open(self.path) as doc_file:
            for line in doc_file:
                code = self._extract_code(line)
                if code:
                    try:
                        tree = ast.parse(code)
                    except SyntaxError:
                        logger.debug(
                            'Could not parse "%s" in %s',
                            line,
                            self.path,
                        )
                        continue

                    for node in ast.walk(tree):
                        for dotted_name in self._process_ast_node(node):
                            dotted_name.is_test = True
                            yield dotted_name


class DjangoSettings(PythonModule):
    """Extract imports from Django settings.py

    These files are used to enable Django components.
    """

    @classmethod
    def create_from_files(cls, top_dir):
        """Find all settings.py files in the package

        For that it gets the path to where top_level.txt points to,
        which is not always a folder:
        - folder example: z3c.dependencychecker itself
        - file example: flake8-isort or any other single file distribution

        Return this very same class, which would allow to call the scan()
        method to get an iterator over all this file's imports.
        """
        if top_dir.suffix == ".py":
            return

        for path, filename in cls.walk_and_filter_folder(top_dir):
            if fnmatch.fnmatch(filename, "*settings.py"):
                yield cls(
                    top_dir,
                    os.path.join(path, filename),
                )

    def scan(self):
        for node in ast.walk(self._get_tree()):
            if isinstance(node, ast.Assign):
                if self._is_installed_apps_assignment(node):
                    if isinstance(node.value, (ast.Tuple, ast.List)):
                        for element in node.value.elts:
                            if isinstance(element, ast.Str):
                                yield DottedName(
                                    element.s,
                                    file_path=self.path,
                                    is_test=self.testing,
                                )

                if self._is_test_runner_assignment(node):
                    if isinstance(node.value, ast.Str):
                        yield DottedName(
                            node.value.s,
                            file_path=self.path,
                            is_test=True,
                        )

    @staticmethod
    def _is_installed_apps_assignment(node):
        if (
            len(node.targets) == 1
            and isinstance(node.targets[0], ast.Name)
            and node.targets[0].id == "INSTALLED_APPS"
        ):
            return True

        return False

    @staticmethod
    def _is_test_runner_assignment(node):
        if (
            len(node.targets) == 1
            and isinstance(node.targets[0], ast.Name)
            and node.targets[0].id == "TEST_RUNNER"
        ):
            return True

        return False


MODULES = (
    PythonModule,
    ZCMLFile,
    FTIFile,
    GSMetadata,
    PythonDocstrings,
    DocFiles,
    DjangoSettings,
)

1	import ast	5✔
2	import fnmatch	5✔
3	import logging	5✔
4	import os	5✔
5	import re	5✔
6	from xml.etree import ElementTree	5✔
7
8	from z3c.dependencychecker.dotted_name import DottedName	5✔
9
10	TEST_REGEX = r"""	5✔
11	{0} # Needs to start with the path separator
12	\w* # There could be some characters (or none)
13	test # has to contain test on it
14	s? # ensure plurals are handled as well
15	( # Needs to end with either a path or a file extension:
16	{0} # path separator
17	\| # OR
18	\w* # some possible characters
19	\. # a dot
20	\w+ # extension
21	)
22	""".format(
23	os.sep
24	)
25
26	TEST_IN_PATH_REGEX = re.compile(TEST_REGEX, re.VERBOSE)	5✔
27
28	logger = logging.getLogger(__name__)	5✔
29
30	FOLDERS_TO_IGNORE = ("node_modules", "__pycache__", "venv")	5✔
31
32
33	class BaseModule:	5✔
34	def __init__(self, package_path, full_path):	5✔
35	self.path = full_path	5✔
36	self._relative_path = self._get_relative_path(package_path, full_path)	5✔
37	self.testing = self._is_test_module()	5✔
38
39	@staticmethod	5✔
40	def _get_relative_path(package_path, full_path):	5✔
41	return str(full_path)[len(str(package_path)) :]	5✔
42
43	def _is_test_module(self):	5✔
44	return bool(re.search(TEST_IN_PATH_REGEX, self._relative_path))	5✔
45
46	@classmethod	5✔
47	def create_from_files(cls, top_dir):	5✔
48	raise NotImplementedError	5✔
49
50	def scan(self):	5✔
51	raise NotImplementedError	5✔
52
53	def walk_and_filter_folder(folder):	5✔
54	for path, folders, filenames in os.walk(folder):	5✔
55	# ignore known folder names
56	folders[:] = [d for d in folders if d not in FOLDERS_TO_IGNORE]	5✔
57	# ignore all folders that start with a dot
58	folders[:] = fnmatch.filter(folders, "[!.]*")	5✔
59	for filename in filenames:	5✔
60	yield path, filename	5✔
61
62
63	class PythonModule(BaseModule):	5✔
64	@classmethod	5✔
65	def create_from_files(cls, top_dir):	5✔
66	"""Find all python files in the package
67
68	For that it gets the path to where top_level.txt points to,
69	which is not always a folder:
70	- folder example: z3c.dependencychecker itself
71	- file example: flake8-isort or any other single file distribution
72
73	Return this very same class, which would allow to call the scan()
74	method to get an iterator over all this file's imports.
75	"""
76	if top_dir.suffix == ".py":	5✔
77	yield cls(top_dir, top_dir)	5✔
78	return	5✔
79
80	for path, filename in cls.walk_and_filter_folder(top_dir):	5✔
81	if filename.endswith(".py"):	5✔
82	yield cls(	5✔
83	top_dir,
84	os.path.join(path, filename),
85	)
86
87	def scan(self):	5✔
88	for node in ast.walk(self._get_tree()):	5✔
89	yield from self._process_ast_node(node)	5✔
90
91	def _get_tree(self):	5✔
92	with open(self.path) as module_file:	5✔
93	source_text = module_file.read()	5✔
94	tree = ast.parse(source_text)	5✔
95	return tree	5✔
96
97	def _process_ast_node(self, node):	5✔
98	if isinstance(node, ast.Import):	5✔
99	for name in node.names:	5✔
100	dotted_name = name.name	5✔
101	yield DottedName(	5✔
102	dotted_name,
103	file_path=self.path,
104	is_test=self.testing,
105	)
106
107	elif isinstance(node, ast.ImportFrom):	5✔
108	if self._is_relative_import(node):	5✔
109	return	5✔
110	for name in node.names:	5✔
111	if name.name == "*":	5✔
112	dotted_name = node.module	5✔
113	else:
114	dotted_name = f"{node.module}.{name.name}"	5✔
115	yield DottedName(	5✔
116	dotted_name,
117	file_path=self.path,
118	is_test=self.testing,
119	)
120
121	@staticmethod	5✔
122	def _is_relative_import(import_node):	5✔
123	return import_node.level > 0	5✔
124
125
126	class ZCMLFile(BaseModule):	5✔
127	"""Extract imports from .zcml files
128
129	These files are in common use in Zope/Plone based projects to define its
130	components and more.
131	"""
132
133	ELEMENTS = {	5✔
134	"include": ("package",),
135	"adapter": ("for", "factory", "provides"),
136	"utility": ("provides", "component"),
137	"browser:page": ("class", "for", "layer"),
138	"subscriber": ("handler", "for"),
139	"securityPolicy": ("component",),
140	"genericsetup:registerProfile": ("provides",),
141	"implements": ("interface",),
142	}
143
144	@classmethod	5✔
145	def create_from_files(cls, top_dir):	5✔
146	"""Find all ZCML files in the package
147
148	Return this very same class, which would allow to call the scan()
149	method to get an iterator over all this file's imports.
150	"""
151	if top_dir.suffix == ".py":	5✔
152	return	5✔
153
154	for path, filename in cls.walk_and_filter_folder(top_dir):	5✔
155	if filename.endswith(".zcml"):	5✔
156	yield cls(	5✔
157	top_dir,
158	os.path.join(path, filename),
159	)
160
161	def scan(self):	5✔
162	tree = ElementTree.parse(self.path).getroot()	5✔
163
164	for element in self.ELEMENTS:	5✔
165	element_namespaced = self._build_namespaced_element(element)	5✔
166	for node in tree.iter(element_namespaced):	5✔
167	for attrib in self.ELEMENTS[element]:	5✔
168	yield from self._extract_dotted_name(node, attrib)	5✔
169
170	def _extract_dotted_name(self, node, attr):	5✔
171	if attr in node.keys():	5✔
172	candidate_text = node.get(attr)	5✔
173	for dotted_name in candidate_text.split(" "):	5✔
174	if not dotted_name or dotted_name.startswith("."):	5✔
175	continue	5✔
176
177	if dotted_name == "*":	5✔
178	continue	5✔
179
180	yield DottedName(	5✔
181	dotted_name,
182	file_path=self.path,
183	is_test=self.testing,
184	)
185
186	@staticmethod	5✔
187	def _build_namespaced_element(element):	5✔
188	if ":" in element:	5✔
189	namespace, name = element.split(":")	5✔
190	return "{{http://namespaces.zope.org/{0}}}{1}".format(	5✔
191	namespace,
192	name,
193	)
194
195	return f"{{http://namespaces.zope.org/zope}}{element}"	5✔
196
197
198	class FTIFile(BaseModule):	5✔
199	"""Extract imports from Factory Type Information files
200
201	These are xml files, usually located inside a types folder and used by
202	Zope/Plone based projects to define its content types.
203	"""
204
205	TYPES_FOLDER = f"{os.sep}types"	5✔
206
207	@classmethod	5✔
208	def create_from_files(cls, top_dir):	5✔
209	"""Find all FTI files, which are xml, in the package
210
211	Return this very same class, which would allow to call the scan()
212	method to get an iterator over all this file's imports.
213	"""
214	if top_dir.suffix == ".py":	5✔
215	return	5✔
216
217	for path, filename in cls.walk_and_filter_folder(top_dir):	5✔
218	if filename.endswith(".xml") and cls.TYPES_FOLDER in path:	5✔
219	yield cls(	5✔
220	top_dir,
221	os.path.join(path, filename),
222	)
223
224	def scan(self):	5✔
225	tree = ElementTree.parse(self.path).getroot()	5✔
226
227	for node in tree.iter("property"):	5✔
228	if "name" in node.keys():	5✔
229	name = node.get("name")	5✔
230	if name in ("klass", "schema"):	5✔
231	if node.text:	5✔
232	yield DottedName(	5✔
233	node.text.strip(),
234	file_path=self.path,
235	is_test=self.testing,
236	)
237
238
239	class GSMetadata(BaseModule):	5✔
240	"""Extract imports from Generic Setup metadata.xml files
241
242	These files are in common use in Zope/Plone to define Generic Setup
243	profile dependencies between projects.
244	"""
245
246	PROFILE_RE = re.compile(r"profile-(?P<dotted_name>[\w.]+):[\w\W]+")	5✔
247
248	@classmethod	5✔
249	def create_from_files(cls, top_dir):	5✔
250	"""Find all metadata.xml files in the package
251
252	Return this very same class, which would allow to call the scan()
253	method to get an iterator over all this file's imports.
254	"""
255	if top_dir.suffix == ".py":	5✔
256	return	5✔
257
258	for path, filename in cls.walk_and_filter_folder(top_dir):	5✔
259	if filename == "metadata.xml":	5✔
260	yield cls(	5✔
261	top_dir,
262	os.path.join(path, filename),
263	)
264
265	def scan(self):	5✔
266	tree = ElementTree.parse(self.path).getroot()	5✔
267
268	for node in tree.iter("dependency"):	5✔
269	if not node.text:	5✔
270	continue	5✔
271	result = self.PROFILE_RE.search(node.text.strip())	5✔
272	if result:	5✔
273	yield DottedName(	5✔
274	result.group("dotted_name"),
275	file_path=self.path,
276	is_test=self.testing,
277	)
278
279
280	class PythonDocstrings(PythonModule):	5✔
281	"""Extract imports from docstrings found inside python modules
282
283	There are some projects that rather than having separate files to keep the
284	tests, they add the inline with the code as docstrings,
285	either at class or method/function level.
286	"""
287
288	NODES_WITH_DOCSTRINGS = (	5✔
289	ast.Module,
290	ast.ClassDef,
291	ast.FunctionDef,
292	)
293
294	def scan(self):	5✔
295	for node in ast.walk(self._get_tree()):	5✔
296	if isinstance(node, self.NODES_WITH_DOCSTRINGS):	5✔
297	docstring = ast.get_docstring(node)	5✔
298	yield from self._parse_docstring(docstring)	5✔
299
300	def _parse_docstring(self, docstring):	5✔
301	if not docstring:	5✔
302	return	5✔
303
304	for line in docstring.split("\n"):	5✔
305	code = self._extract_code(line)	5✔
306	if code:	5✔
307	try:	5✔
308	tree = ast.parse(code)	5✔
309	except SyntaxError:	5✔
310	logger.debug(	5✔
311	'Could not parse "%s" in %s',
312	line,
313	self.path,
314	)
315	continue	5✔
316
317	for node in ast.walk(tree):	5✔
318	for dotted_name in self._process_ast_node(node):	5✔
319	dotted_name.is_test = True	5✔
320	yield dotted_name	5✔
321
322	@staticmethod	5✔
323	def _extract_code(line):	5✔
324	if ">>>" in line:	5✔
325	position = line.find(">>>") + 3	5✔
326	return line[position:].strip()	5✔
327
328
329	class DocFiles(PythonDocstrings):	5✔
330	"""Extract imports from documentation-like documents
331
332	One extended testing pattern (at least in Zope/Plone based projects) is to
333	write documentation in txt/rst files that contain tests to assert that
334	documentation.
335	"""
336
337	@classmethod	5✔
338	def create_from_files(cls, top_dir):	5✔
339	"""Find all documentation files in the package
340
341	For that it gets the path to where top_level.txt points to,
342	which is not always a folder:
343	- folder example: z3c.dependencychecker itself
344	- file example: flake8-isort or any other single file distribution
345
346	Return this very same class, which would allow to call the scan()
347	method to get an iterator over all this file's imports.
348	"""
349	if top_dir.suffix == ".py":	5✔
350	return	5✔
351
352	for path, filename in cls.walk_and_filter_folder(top_dir):	5✔
353	if filename.endswith(".txt") or filename.endswith(".rst"):	5✔
354	yield cls(	5✔
355	top_dir,
356	os.path.join(path, filename),
357	)
358
359	def scan(self):	5✔
360	try:	5✔
361	yield from self._scan()	5✔
NEW 362	except UnicodeDecodeError:	×
NEW 363	logger.error("Unicode Problems parsing %s", self.path)	×
364
365	def _scan(self):	5✔
366	with open(self.path) as doc_file:	5✔
367	for line in doc_file:	5✔
368	code = self._extract_code(line)	5✔
369	if code:	5✔
370	try:	5✔
371	tree = ast.parse(code)	5✔
372	except SyntaxError:	5✔
373	logger.debug(	5✔
374	'Could not parse "%s" in %s',
375	line,
376	self.path,
377	)
378	continue	5✔
379
380	for node in ast.walk(tree):	5✔
381	for dotted_name in self._process_ast_node(node):	5✔
382	dotted_name.is_test = True	5✔
383	yield dotted_name	5✔
384
385
386	class DjangoSettings(PythonModule):	5✔
387	"""Extract imports from Django settings.py
388
389	These files are used to enable Django components.
390	"""
391
392	@classmethod	5✔
393	def create_from_files(cls, top_dir):	5✔
394	"""Find all settings.py files in the package
395
396	For that it gets the path to where top_level.txt points to,
397	which is not always a folder:
398	- folder example: z3c.dependencychecker itself
399	- file example: flake8-isort or any other single file distribution
400
401	Return this very same class, which would allow to call the scan()
402	method to get an iterator over all this file's imports.
403	"""
404	if top_dir.suffix == ".py":	5✔
405	return	5✔
406
407	for path, filename in cls.walk_and_filter_folder(top_dir):	5✔
408	if fnmatch.fnmatch(filename, "*settings.py"):	5✔
409	yield cls(	5✔
410	top_dir,
411	os.path.join(path, filename),
412	)
413
414	def scan(self):	5✔
415	for node in ast.walk(self._get_tree()):	5✔
416	if isinstance(node, ast.Assign):	5✔
417	if self._is_installed_apps_assignment(node):	5✔
418	if isinstance(node.value, (ast.Tuple, ast.List)):	5✔
419	for element in node.value.elts:	5✔
420	if isinstance(element, ast.Str):	5✔
421	yield DottedName(	5✔
422	element.s,
423	file_path=self.path,
424	is_test=self.testing,
425	)
426
427	if self._is_test_runner_assignment(node):	5✔
428	if isinstance(node.value, ast.Str):	5✔
429	yield DottedName(	5✔
430	node.value.s,
431	file_path=self.path,
432	is_test=True,
433	)
434
435	@staticmethod	5✔
436	def _is_installed_apps_assignment(node):	5✔
437	if (	5✔
438	len(node.targets) == 1
439	and isinstance(node.targets[0], ast.Name)
440	and node.targets[0].id == "INSTALLED_APPS"
441	):
442	return True	5✔
443
444	return False	5✔
445
446	@staticmethod	5✔
447	def _is_test_runner_assignment(node):	5✔
448	if (	5✔
449	len(node.targets) == 1
450	and isinstance(node.targets[0], ast.Name)
451	and node.targets[0].id == "TEST_RUNNER"
452	):
453	return True	5✔
454
455	return False	5✔
456
457
458	MODULES = (	5✔
459	PythonModule,
460	ZCMLFile,
461	FTIFile,
462	GSMetadata,
463	PythonDocstrings,
464	DocFiles,
465	DjangoSettings,
466	)

reinout / z3c.dependencychecker / 7531125911

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous