1094

pending completion

Build # 1094

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

fix: check a YAML file with the text plugin (#249)

The merged style is not being validated anymore, only individual style files.

Run Details

345 of 420 branches covered (82.14%)

Branch coverage included in aggregate %.

21 of 21 new or added lines in 4 files covered. (100.0%)

17 existing lines in 2 files now uncovered.

1259 of 1330 relevant lines covered (94.66%)

3.79 hits per line

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

83.45

/src/nitpick/style.py

"""Style files."""
import logging
from collections import OrderedDict
from pathlib import Path
from typing import Any, Dict, List, Optional, Set, Type
from urllib.parse import urlparse, urlunparse

import click
import requests
from identify import identify
from marshmallow import Schema
from slugify import slugify
from toml import TomlDecodeError

from nitpick import __version__, fields
from nitpick.app import NitpickApp
from nitpick.constants import (
    MERGED_STYLE_TOML,
    NITPICK_STYLE_TOML,
    NITPICK_STYLES_INCLUDE_JMEX,
    PROJECT_NAME,
    RAW_GITHUB_CONTENT_BASE_URL,
    TOML_EXTENSION,
)
from nitpick.exceptions import Deprecation
from nitpick.formats import TOMLFormat
from nitpick.generic import MergeDict, climb_directory_tree, is_url, pretty_exception, search_dict
from nitpick.plugins.base import NitpickPlugin
from nitpick.plugins.pyproject_toml import PyProjectTomlPlugin
from nitpick.schemas import BaseStyleSchema, NitpickSectionSchema, flatten_marshmallow_errors
from nitpick.typedefs import JsonDict, StrOrList

LOGGER = logging.getLogger(__name__)


class Style:
    """Include styles recursively from one another."""

    def __init__(self) -> None:
        self._all_styles = MergeDict()
        self._already_included = set()  # type: Set[str]
        self._first_full_path = ""  # type: str

        self._dynamic_schema_class = BaseStyleSchema  # type: type
        self.rebuild_dynamic_schema()
        self.style_errors = {}  # type: Dict[str, Any]

    @staticmethod
    def get_default_style_url():
        """Return the URL of the default style for the current version."""
        return "{}/v{}/{}".format(RAW_GITHUB_CONTENT_BASE_URL, __version__, NITPICK_STYLE_TOML)

    def find_initial_styles(self, configured_styles: StrOrList):
        """Find the initial style(s) and include them."""
        if configured_styles:
            chosen_styles = configured_styles
            log_message = "Styles configured in {}: %s".format(PyProjectTomlPlugin.file_name)
        else:
            paths = climb_directory_tree(NitpickApp.current().root_dir, [NITPICK_STYLE_TOML])
            if paths:
                chosen_styles = str(sorted(paths)[0])
                log_message = "Found style climbing the directory tree: %s"
            else:
                chosen_styles = self.get_default_style_url()
                log_message = "Loading default Nitpick style %s"
        LOGGER.info(log_message, chosen_styles)

        self.include_multiple_styles(chosen_styles)

    @staticmethod
    def validate_schema(schema: Type[Schema], path_from_root: str, original_data: JsonDict) -> Dict[str, List[str]]:
        """Validate the schema for the file."""
        if not schema:
            return {}

        inherited_schema = schema is not BaseStyleSchema
        data_to_validate = original_data if inherited_schema else {path_from_root: None}
        local_errors = schema().validate(data_to_validate)
        if local_errors and inherited_schema:
            local_errors = {path_from_root: local_errors}
        return local_errors

    def include_multiple_styles(self, chosen_styles: StrOrList) -> None:
        """Include a list of styles (or just one) into this style tree."""
        style_uris = [chosen_styles] if isinstance(chosen_styles, str) else chosen_styles  # type: List[str]
        for style_uri in style_uris:
            style_path = self.get_style_path(style_uri)  # type: Optional[Path]
            if not style_path:
                continue

            toml = TOMLFormat(path=style_path)
            app = NitpickApp.current()
            try:
                read_toml_dict = toml.as_data
            except TomlDecodeError as err:
                app.add_style_error(style_path.name, pretty_exception(err, "Invalid TOML"))
                # If the TOML itself could not be parsed, we can't go on
                return

            try:
                display_name = str(style_path.relative_to(app.root_dir))
            except ValueError:
                display_name = style_uri

            toml_dict = self._validate_config(read_toml_dict)

            if self.style_errors:
                NitpickApp.current().add_style_error(
                    display_name, "Invalid config:", flatten_marshmallow_errors(self.style_errors)
                )
            self._all_styles.add(toml_dict)

            sub_styles = search_dict(NITPICK_STYLES_INCLUDE_JMEX, toml_dict, [])  # type: StrOrList
            if sub_styles:
                self.include_multiple_styles(sub_styles)

    def _validate_config(self, config_dict: dict) -> dict:
        self.style_errors = {}
        toml_dict = OrderedDict()
        for key, value_dict in config_dict.items():
            from nitpick.config import FileNameCleaner  # pylint: disable=import-outside-toplevel

            cleaner = FileNameCleaner(key)
            toml_dict[cleaner.path_from_root] = value_dict
            if key == PROJECT_NAME:
                schemas = [NitpickSectionSchema]
            else:
                schemas = [
                    plugin.validation_schema
                    for plugin in NitpickApp.current().plugin_manager.hook.handler(  # pylint: disable=no-member
                        file_name=cleaner.path_from_root, tags=cleaner.tags
                    )
                ]
                if not schemas:
                    self.style_errors[key] = [BaseStyleSchema.error_messages["unknown"]]

            all_errors = {}
            valid_schema = False
            for schema in schemas:
                errors = self.validate_schema(schema, cleaner.path_from_root, value_dict)
                if not errors:
                    # When multiple schemas match a file type, exit when a valid schema is found
                    valid_schema = True
                    break
                all_errors.update(errors)

            if not valid_schema:
                Deprecation.jsonfile_section(all_errors, False)
                self.style_errors.update(all_errors)
        return toml_dict

    def get_style_path(self, style_uri: str) -> Optional[Path]:
        """Get the style path from the URI. Add the .toml extension if it's missing."""
        clean_style_uri = style_uri.strip()

        style_path = None
        if is_url(clean_style_uri) or is_url(self._first_full_path):
            style_path = self.fetch_style_from_url(clean_style_uri)
        elif clean_style_uri:
            style_path = self.fetch_style_from_local_path(clean_style_uri)
        return style_path

    def fetch_style_from_url(self, url: str) -> Optional[Path]:
        """Fetch a style file from a URL, saving the contents in the cache dir."""
        if NitpickApp.current().offline:
            # No style will be fetched in offline mode
            return None

        if self._first_full_path and not is_url(url):
            prefix, rest = self._first_full_path.split(":/")
            domain_plus_url = str(rest).strip("/").rstrip("/") + "/" + url
            new_url = "{}://{}".format(prefix, domain_plus_url)
        else:
            new_url = url

        parsed_url = list(urlparse(new_url))
        if not parsed_url[2].endswith(TOML_EXTENSION):
            parsed_url[2] += TOML_EXTENSION
        new_url = urlunparse(parsed_url)

        if new_url in self._already_included:
            return None

        if not NitpickApp.current().cache_dir:
            raise FileNotFoundError("Cache dir does not exist")

        try:
            response = requests.get(new_url)
        except requests.ConnectionError:
            click.secho(
                "Your network is unreachable. Fix your connection or use {} / {}=1".format(
                    NitpickApp.format_flag(NitpickApp.Flags.OFFLINE), NitpickApp.format_env(NitpickApp.Flags.OFFLINE)
                ),
                fg="red",
                err=True,
            )
            return None
        if not response.ok:
            raise FileNotFoundError("Error {} fetching style URL {}".format(response, new_url))

        # Save the first full path to be used by the next files without parent.
        if not self._first_full_path:
            self._first_full_path = new_url.rsplit("/", 1)[0]

        contents = response.text
        style_path = NitpickApp.current().cache_dir / "{}.toml".format(slugify(new_url))
        NitpickApp.current().cache_dir.mkdir(parents=True, exist_ok=True)
        style_path.write_text(contents)

        LOGGER.info("Loading style from URL %s into %s", new_url, style_path)
        self._already_included.add(new_url)

        return style_path

    def fetch_style_from_local_path(self, partial_file_name: str) -> Optional[Path]:
        """Fetch a style file from a local path."""
        if partial_file_name and not partial_file_name.endswith(TOML_EXTENSION):
            partial_file_name += TOML_EXTENSION
        expanded_path = Path(partial_file_name).expanduser()

        if not str(expanded_path).startswith("/") and self._first_full_path:
            # Prepend the previous path to the partial file name.
            style_path = Path(self._first_full_path) / expanded_path
        else:
            # Get the absolute path, be it from a root path (starting with slash) or from the current dir.
            style_path = Path(expanded_path).absolute()

        # Save the first full path to be used by the next files without parent.
        if not self._first_full_path:
            self._first_full_path = str(style_path.resolve().parent)

        if str(style_path) in self._already_included:
            return None

        if not style_path.exists():
            raise FileNotFoundError("Local style file does not exist: {}".format(style_path))

        LOGGER.info("Loading style from file: %s", style_path)
        self._already_included.add(str(style_path))
        return style_path

    def merge_toml_dict(self) -> JsonDict:
        """Merge all included styles into a TOML (actually JSON) dictionary."""
        app = NitpickApp.current()
        if not app.cache_dir:
            return {}
        merged_dict = self._all_styles.merge()
        # TODO: check if the merged style file is still needed
        merged_style_path = app.cache_dir / MERGED_STYLE_TOML  # type: Path
        toml = TOMLFormat(data=merged_dict)

        attempt = 1
        while attempt < 5:
            try:
                app.cache_dir.mkdir(parents=True, exist_ok=True)
                merged_style_path.write_text(toml.reformatted)
                break
            except OSError:
                attempt += 1

        return merged_dict

    @staticmethod
    def file_field_pair(file_name: str, base_file_class: Type[NitpickPlugin]) -> Dict[str, fields.Field]:
        """Return a schema field with info from a config file class."""
        unique_file_name_with_underscore = slugify(file_name, separator="_")

        kwargs = {"data_key": file_name}
        if base_file_class.validation_schema:
            field = fields.Nested(base_file_class.validation_schema, **kwargs)
        else:
            # For default files (pyproject.toml, setup.cfg...), there is no strict schema;
            # it can be anything they allow.
            # It's out of Nitpick's scope to validate those files.
            field = fields.Dict(fields.String, **kwargs)
        return {unique_file_name_with_underscore: field}

    def rebuild_dynamic_schema(self, data: JsonDict = None) -> None:
        """Rebuild the dynamic Marshmallow schema when needed, adding new fields that were found on the style."""
        new_files_found = OrderedDict()  # type: Dict[str, fields.Field]

        if data is None:
            # Data is empty; so this is the first time the dynamic class is being rebuilt.
            # Loop on classes with predetermined names, and add fields for them on the dynamic validation schema.
            # E.g.: setup.cfg, pre-commit, pyproject.toml: files whose names we already know at this point.
            for subclass in NitpickPlugin.fixed_name_classes:
                new_files_found.update(self.file_field_pair(subclass.file_name, subclass))
        else:
            handled_tags = {}  # type: Dict[str, Type[NitpickPlugin]]

            # Data was provided; search it to find new dynamic files to add to the validation schema).
            # E.g.: JSON files that were configured on some TOML style file.
            for subclass in NitpickPlugin.dynamic_name_classes:
                for tag in subclass.identify_tags:
                    # A tag can only be handled by a single subclass.
                    # If more than one class handle a tag, the latest one will be the handler.
                    handled_tags[tag] = subclass

                jmex = subclass.get_compiled_jmespath_file_names()
                for configured_file_name in search_dict(jmex, data, []):
                    new_files_found.update(self.file_field_pair(configured_file_name, subclass))

            self._find_subclasses(data, handled_tags, new_files_found)

        # Only recreate the schema if new fields were found.
        if new_files_found:
            self._dynamic_schema_class = type("DynamicStyleSchema", (self._dynamic_schema_class,), new_files_found)

    def _find_subclasses(self, data, handled_tags, new_files_found):
        for possible_file in data.keys():
            found_subclasses = []
            for file_tag in identify.tags_from_filename(possible_file):
                handler_subclass = handled_tags.get(file_tag)
                if handler_subclass:
                    found_subclasses.append(handler_subclass)

            for found_subclass in found_subclasses:
                new_files_found.update(self.file_field_pair(possible_file, found_subclass))

1	"""Style files."""
2	import logging	4✔
3	from collections import OrderedDict	4✔
4	from pathlib import Path	4✔
5	from typing import Any, Dict, List, Optional, Set, Type	4✔
6	from urllib.parse import urlparse, urlunparse	4✔
7
8	import click	4✔
9	import requests	4✔
10	from identify import identify	4✔
11	from marshmallow import Schema	4✔
12	from slugify import slugify	4✔
13	from toml import TomlDecodeError	4✔
14
15	from nitpick import __version__, fields	4✔
16	from nitpick.app import NitpickApp	4✔
17	from nitpick.constants import (	4✔
18	MERGED_STYLE_TOML,
19	NITPICK_STYLE_TOML,
20	NITPICK_STYLES_INCLUDE_JMEX,
21	PROJECT_NAME,
22	RAW_GITHUB_CONTENT_BASE_URL,
23	TOML_EXTENSION,
24	)
25	from nitpick.exceptions import Deprecation	4✔
26	from nitpick.formats import TOMLFormat	4✔
27	from nitpick.generic import MergeDict, climb_directory_tree, is_url, pretty_exception, search_dict	4✔
28	from nitpick.plugins.base import NitpickPlugin	4✔
29	from nitpick.plugins.pyproject_toml import PyProjectTomlPlugin	4✔
30	from nitpick.schemas import BaseStyleSchema, NitpickSectionSchema, flatten_marshmallow_errors	4✔
31	from nitpick.typedefs import JsonDict, StrOrList	4✔
32
33	LOGGER = logging.getLogger(__name__)	4✔
34
35
36	class Style:	4✔
37	"""Include styles recursively from one another."""
38
39	def __init__(self) -> None:	4✔
40	self._all_styles = MergeDict()	4✔
41	self._already_included = set() # type: Set[str]	4✔
42	self._first_full_path = "" # type: str	4✔
43
44	self._dynamic_schema_class = BaseStyleSchema # type: type	4✔
45	self.rebuild_dynamic_schema()	4✔
46	self.style_errors = {} # type: Dict[str, Any]	4✔
47
48	@staticmethod	4✔
49	def get_default_style_url():	1✔
50	"""Return the URL of the default style for the current version."""
51	return "{}/v{}/{}".format(RAW_GITHUB_CONTENT_BASE_URL, __version__, NITPICK_STYLE_TOML)	4✔
52
53	def find_initial_styles(self, configured_styles: StrOrList):	4✔
54	"""Find the initial style(s) and include them."""
55	if configured_styles:	4✔
56	chosen_styles = configured_styles	4✔
57	log_message = "Styles configured in {}: %s".format(PyProjectTomlPlugin.file_name)	4✔
58	else:
59	paths = climb_directory_tree(NitpickApp.current().root_dir, [NITPICK_STYLE_TOML])	4✔
60	if paths:	4✔
61	chosen_styles = str(sorted(paths)[0])	4✔
62	log_message = "Found style climbing the directory tree: %s"	4✔
63	else:
64	chosen_styles = self.get_default_style_url()	4✔
65	log_message = "Loading default Nitpick style %s"	4✔
66	LOGGER.info(log_message, chosen_styles)	4✔
67
68	self.include_multiple_styles(chosen_styles)	4✔
69
70	@staticmethod	4✔
71	def validate_schema(schema: Type[Schema], path_from_root: str, original_data: JsonDict) -> Dict[str, List[str]]:	4✔
72	"""Validate the schema for the file."""
73	if not schema:	4✔
74	return {}	4✔
75
76	inherited_schema = schema is not BaseStyleSchema	4✔
77	data_to_validate = original_data if inherited_schema else {path_from_root: None}	4✔
78	local_errors = schema().validate(data_to_validate)	4✔
79	if local_errors and inherited_schema:	4✔
80	local_errors = {path_from_root: local_errors}	4✔
81	return local_errors	4✔
82
83	def include_multiple_styles(self, chosen_styles: StrOrList) -> None:	4✔
84	"""Include a list of styles (or just one) into this style tree."""
85	style_uris = [chosen_styles] if isinstance(chosen_styles, str) else chosen_styles # type: List[str]	4✔
86	for style_uri in style_uris:	4✔
87	style_path = self.get_style_path(style_uri) # type: Optional[Path]	4✔
88	if not style_path:	4✔
89	continue	4✔
90
91	toml = TOMLFormat(path=style_path)	4✔
92	app = NitpickApp.current()	4✔
93	try:	4✔
94	read_toml_dict = toml.as_data	4✔
95	except TomlDecodeError as err:	4✔
96	app.add_style_error(style_path.name, pretty_exception(err, "Invalid TOML"))	4✔
97	# If the TOML itself could not be parsed, we can't go on
98	return	4✔
99
100	try:	4✔
101	display_name = str(style_path.relative_to(app.root_dir))	4✔
102	except ValueError:	4✔
103	display_name = style_uri	4✔
104
105	toml_dict = self._validate_config(read_toml_dict)	4✔
106
107	if self.style_errors:	4✔
108	NitpickApp.current().add_style_error(	4✔
109	display_name, "Invalid config:", flatten_marshmallow_errors(self.style_errors)
110	)
111	self._all_styles.add(toml_dict)	4✔
112
113	sub_styles = search_dict(NITPICK_STYLES_INCLUDE_JMEX, toml_dict, []) # type: StrOrList	4✔
114	if sub_styles:	4✔
115	self.include_multiple_styles(sub_styles)	4✔
116
117	def _validate_config(self, config_dict: dict) -> dict:	4✔
118	self.style_errors = {}	4✔
119	toml_dict = OrderedDict()	4✔
120	for key, value_dict in config_dict.items():	4✔
121	from nitpick.config import FileNameCleaner # pylint: disable=import-outside-toplevel	4✔
122
123	cleaner = FileNameCleaner(key)	4✔
124	toml_dict[cleaner.path_from_root] = value_dict	4✔
125	if key == PROJECT_NAME:	4✔
126	schemas = [NitpickSectionSchema]	4✔
127	else:
128	schemas = [	4✔
129	plugin.validation_schema
130	for plugin in NitpickApp.current().plugin_manager.hook.handler( # pylint: disable=no-member
131	file_name=cleaner.path_from_root, tags=cleaner.tags
132	)
133	]
134	if not schemas:	4✔
135	self.style_errors[key] = [BaseStyleSchema.error_messages["unknown"]]	4✔
136
137	all_errors = {}	4✔
138	valid_schema = False	4✔
139	for schema in schemas:	4✔
140	errors = self.validate_schema(schema, cleaner.path_from_root, value_dict)	4✔
141	if not errors:	4✔
142	# When multiple schemas match a file type, exit when a valid schema is found
143	valid_schema = True	4✔
144	break	4✔
145	all_errors.update(errors)	4✔
146
147	if not valid_schema:	4✔
148	Deprecation.jsonfile_section(all_errors, False)	4✔
149	self.style_errors.update(all_errors)	4✔
150	return toml_dict	4✔
151
152	def get_style_path(self, style_uri: str) -> Optional[Path]:	4✔
153	"""Get the style path from the URI. Add the .toml extension if it's missing."""
154	clean_style_uri = style_uri.strip()	4✔
155
156	style_path = None	4✔
157	if is_url(clean_style_uri) or is_url(self._first_full_path):	4✔
158	style_path = self.fetch_style_from_url(clean_style_uri)	4✔
159	elif clean_style_uri:	4!
160	style_path = self.fetch_style_from_local_path(clean_style_uri)	4✔
161	return style_path	4✔
162
163	def fetch_style_from_url(self, url: str) -> Optional[Path]:	4✔
164	"""Fetch a style file from a URL, saving the contents in the cache dir."""
165	if NitpickApp.current().offline:	4✔
166	# No style will be fetched in offline mode
167	return None	4✔
168
169	if self._first_full_path and not is_url(url):	4✔
170	prefix, rest = self._first_full_path.split(":/")	4✔
171	domain_plus_url = str(rest).strip("/").rstrip("/") + "/" + url	4✔
172	new_url = "{}://{}".format(prefix, domain_plus_url)	4✔
173	else:
174	new_url = url	4✔
175
176	parsed_url = list(urlparse(new_url))	4✔
177	if not parsed_url[2].endswith(TOML_EXTENSION):	4✔
178	parsed_url[2] += TOML_EXTENSION	4✔
179	new_url = urlunparse(parsed_url)	4✔
180
181	if new_url in self._already_included:	4!
182	return None	×
183
184	if not NitpickApp.current().cache_dir:	4!
185	raise FileNotFoundError("Cache dir does not exist")	×
186
187	try:	4✔
188	response = requests.get(new_url)	4✔
189	except requests.ConnectionError:	4✔
190	click.secho(	4✔
191	"Your network is unreachable. Fix your connection or use {} / {}=1".format(
192	NitpickApp.format_flag(NitpickApp.Flags.OFFLINE), NitpickApp.format_env(NitpickApp.Flags.OFFLINE)
193	),
194	fg="red",
195	err=True,
196	)
197	return None	4✔
198	if not response.ok:	4!
199	raise FileNotFoundError("Error {} fetching style URL {}".format(response, new_url))	×
200
201	# Save the first full path to be used by the next files without parent.
202	if not self._first_full_path:	4✔
203	self._first_full_path = new_url.rsplit("/", 1)[0]	4✔
204
205	contents = response.text	4✔
206	style_path = NitpickApp.current().cache_dir / "{}.toml".format(slugify(new_url))	4✔
207	NitpickApp.current().cache_dir.mkdir(parents=True, exist_ok=True)	4✔
208	style_path.write_text(contents)	4✔
209
210	LOGGER.info("Loading style from URL %s into %s", new_url, style_path)	4✔
211	self._already_included.add(new_url)	4✔
212
213	return style_path	4✔
214
215	def fetch_style_from_local_path(self, partial_file_name: str) -> Optional[Path]:	4✔
216	"""Fetch a style file from a local path."""
217	if partial_file_name and not partial_file_name.endswith(TOML_EXTENSION):	4✔
218	partial_file_name += TOML_EXTENSION	4✔
219	expanded_path = Path(partial_file_name).expanduser()	4✔
220
221	if not str(expanded_path).startswith("/") and self._first_full_path:	4✔
222	# Prepend the previous path to the partial file name.
223	style_path = Path(self._first_full_path) / expanded_path	4✔
224	else:
225	# Get the absolute path, be it from a root path (starting with slash) or from the current dir.
226	style_path = Path(expanded_path).absolute()	4✔
227
228	# Save the first full path to be used by the next files without parent.
229	if not self._first_full_path:	4✔
230	self._first_full_path = str(style_path.resolve().parent)	4✔
231
232	if str(style_path) in self._already_included:	4✔
233	return None	4✔
234
235	if not style_path.exists():	4!
236	raise FileNotFoundError("Local style file does not exist: {}".format(style_path))	×
237
238	LOGGER.info("Loading style from file: %s", style_path)	4✔
239	self._already_included.add(str(style_path))	4✔
240	return style_path	4✔
241
242	def merge_toml_dict(self) -> JsonDict:	4✔
243	"""Merge all included styles into a TOML (actually JSON) dictionary."""
244	app = NitpickApp.current()	4✔
245	if not app.cache_dir:	4!
246	return {}	×
247	merged_dict = self._all_styles.merge()	4✔
248	# TODO: check if the merged style file is still needed
249	merged_style_path = app.cache_dir / MERGED_STYLE_TOML # type: Path	4✔
250	toml = TOMLFormat(data=merged_dict)	4✔
251
252	attempt = 1	4✔
253	while attempt < 5:	4!
254	try:	4✔
255	app.cache_dir.mkdir(parents=True, exist_ok=True)	4✔
256	merged_style_path.write_text(toml.reformatted)	4✔
257	break	4✔
258	except OSError:	×
259	attempt += 1	×
260
261	return merged_dict	4✔
262
263	@staticmethod	4✔
264	def file_field_pair(file_name: str, base_file_class: Type[NitpickPlugin]) -> Dict[str, fields.Field]:	4✔
265	"""Return a schema field with info from a config file class."""
266	unique_file_name_with_underscore = slugify(file_name, separator="_")	4✔
267
268	kwargs = {"data_key": file_name}	4✔
269	if base_file_class.validation_schema:	4!
UNCOV 270	field = fields.Nested(base_file_class.validation_schema, **kwargs)	×
271	else:
272	# For default files (pyproject.toml, setup.cfg...), there is no strict schema;
273	# it can be anything they allow.
274	# It's out of Nitpick's scope to validate those files.
275	field = fields.Dict(fields.String, **kwargs)	4✔
276	return {unique_file_name_with_underscore: field}	4✔
277
278	def rebuild_dynamic_schema(self, data: JsonDict = None) -> None:	4✔
279	"""Rebuild the dynamic Marshmallow schema when needed, adding new fields that were found on the style."""
280	new_files_found = OrderedDict() # type: Dict[str, fields.Field]	4✔
281
282	if data is None:	4!
283	# Data is empty; so this is the first time the dynamic class is being rebuilt.
284	# Loop on classes with predetermined names, and add fields for them on the dynamic validation schema.
285	# E.g.: setup.cfg, pre-commit, pyproject.toml: files whose names we already know at this point.
286	for subclass in NitpickPlugin.fixed_name_classes:	4✔
287	new_files_found.update(self.file_field_pair(subclass.file_name, subclass))	4✔
288	else:
UNCOV 289	handled_tags = {} # type: Dict[str, Type[NitpickPlugin]]	×
290
291	# Data was provided; search it to find new dynamic files to add to the validation schema).
292	# E.g.: JSON files that were configured on some TOML style file.
UNCOV 293	for subclass in NitpickPlugin.dynamic_name_classes:	×
UNCOV 294	for tag in subclass.identify_tags:	×
295	# A tag can only be handled by a single subclass.
296	# If more than one class handle a tag, the latest one will be the handler.
UNCOV 297	handled_tags[tag] = subclass	×
298
UNCOV 299	jmex = subclass.get_compiled_jmespath_file_names()	×
UNCOV 300	for configured_file_name in search_dict(jmex, data, []):	×
301	new_files_found.update(self.file_field_pair(configured_file_name, subclass))	×
302
UNCOV 303	self._find_subclasses(data, handled_tags, new_files_found)	×
304
305	# Only recreate the schema if new fields were found.
306	if new_files_found:	4!
307	self._dynamic_schema_class = type("DynamicStyleSchema", (self._dynamic_schema_class,), new_files_found)	4✔
308
309	def _find_subclasses(self, data, handled_tags, new_files_found):	4✔
UNCOV 310	for possible_file in data.keys():	×
UNCOV 311	found_subclasses = []	×
UNCOV 312	for file_tag in identify.tags_from_filename(possible_file):	×
UNCOV 313	handler_subclass = handled_tags.get(file_tag)	×
UNCOV 314	if handler_subclass:	×
UNCOV 315	found_subclasses.append(handler_subclass)	×
316
UNCOV 317	for found_subclass in found_subclasses:	×
UNCOV 318	new_files_found.update(self.file_field_pair(possible_file, found_subclass))	×

andreoliwa / nitpick / 1094

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