Coverage for sphinx_reports/CodeCoverage.py: 18%

1# ==================================================================================================================== #

2# _ _ _ #

3# ___ _ __ | |__ (_)_ __ __ __ _ __ ___ _ __ ___ _ __| |_ ___ #

4# / __| '_ \| '_ \| | '_ \\ \/ /____| '__/ _ \ '_ \ / _ \| '__| __/ __| #

5# \__ \ |_) | | | | | | | |> <_____| | | __/ |_) | (_) | | | |_\__ \ #

6# |___/ .__/|_| |_|_|_| |_/_/\_\ |_| \___| .__/ \___/|_| \__|___/ #

7# |_| |_| #

8# ==================================================================================================================== #

9# Authors: #

10# Patrick Lehmann #

11# #

12# License: #

13# ==================================================================================================================== #

15# #

16# Licensed under the Apache License, Version 2.0 (the "License"); #

17# you may not use this file except in compliance with the License. #

18# You may obtain a copy of the License at #

19# #

20# http://www.apache.org/licenses/LICENSE-2.0 #

21# #

22# Unless required by applicable law or agreed to in writing, software #

23# distributed under the License is distributed on an "AS IS" BASIS, #

24# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #

25# See the License for the specific language governing permissions and #

26# limitations under the License. #

27# #

28# SPDX-License-Identifier: Apache-2.0 #

29# ==================================================================================================================== #

30#

31"""

32**Report code coverage as Sphinx documentation page(s).**

33"""

34from pathlib import Path

35from typing import Dict, Tuple, Any, List, Mapping, Generator, TypedDict, Union, Optional as Nullable, ClassVar

37from docutils import nodes

38from docutils.parsers.rst.directives import flag

39from sphinx.addnodes import toctree

40from sphinx.application import Sphinx

41from sphinx.config import Config

42from sphinx.directives.code import LiteralIncludeReader

43from sphinx.util.docutils import new_document

44from pyTooling.Decorators import export

46from sphinx_reports.Common import ReportExtensionError, LegendStyle

47from sphinx_reports.Sphinx import strip, stripAndNormalize, BaseDirective

48from sphinx_reports.DataModel.CodeCoverage import PackageCoverage, Coverage, ModuleCoverage

49from sphinx_reports.Adapter.Coverage import Analyzer

52class package_DictType(TypedDict):

53 name: str

54 json_report: Path

55 fail_below: int

56 levels: Union[str, Dict[Union[int, str], Dict[str, str]]]

59@export

60class CodeCoverageBase(BaseDirective):

62 option_spec = {

63 "class": strip,

64 "reportid": stripAndNormalize

65 }

67 defaultCoverageDefinitions = {

68 "default": {

69 10: {"class": "report-cov-below10", "desc": "almost unused"},

70 20: {"class": "report-cov-below20", "desc": "almost unused"},

71 30: {"class": "report-cov-below30", "desc": "almost unused"},

72 40: {"class": "report-cov-below40", "desc": "poorly used"},

73 50: {"class": "report-cov-below50", "desc": "poorly used"},

74 60: {"class": "report-cov-below60", "desc": "somehow used"},

75 70: {"class": "report-cov-below70", "desc": "somehow used"},

76 80: {"class": "report-cov-below80", "desc": "somehow used"},

77 85: {"class": "report-cov-below85", "desc": "well used"},

78 90: {"class": "report-cov-below90", "desc": "well used"},

79 95: {"class": "report-cov-below95", "desc": "well used"},

80 100: {"class": "report-cov-below100", "desc": "excellently used"},

81 "error": {"class": "report-cov-error", "desc": "internal error"},

82 }

83 }

85 configPrefix: str = "codecov"

86 configValues: Dict[str, Tuple[Any, str, Any]] = {

87 f"{configPrefix}_packages": ({}, "env", Dict),

88 f"{configPrefix}_levels": (defaultCoverageDefinitions, "env", Dict),

89 } #: A dictionary of all configuration values used by code coverage directives.

91 _coverageLevelDefinitions: ClassVar[Dict[str, Dict[Union[int, str], Dict[str, str]]]] = {}

92 _packageConfigurations: ClassVar[Dict[str, package_DictType]] = {}

94 _cssClasses: List[str]

95 _reportID: str

96 _levels: Dict[Union[int, str], Dict[str, str]]

98 def _CheckOptions(self) -> None:

99 """

100 Parse all directive options or use default values.

101 """

102 cssClasses = self._ParseStringOption("class", "", r"(\w+)?( +\w+)*")

103

104 self._reportID = self._ParseStringOption("reportid")

105 self._cssClasses = [] if cssClasses == "" else cssClasses.split(" ")

106

107 @classmethod

108 def CheckConfiguration(cls, sphinxApplication: Sphinx, sphinxConfiguration: Config) -> None:

109 """

110 Check configuration fields and load necessary values.

111

112 :param sphinxApplication: Sphinx application instance.

113 :param sphinxConfiguration: Sphinx configuration instance.

114 """

115 cls._CheckLevelsConfiguration(sphinxConfiguration)

116 cls._CheckPackagesConfiguration(sphinxConfiguration)

117

118 @classmethod

119 def ReadReports(cls, sphinxApplication: Sphinx) -> None:

120 """

121 Read code coverage report files.

122

123 :param sphinxApplication: Sphinx application instance.

124 """

125 print(f"[REPORT] Reading code coverage reports ...")

126

127 @classmethod

128 def _CheckLevelsConfiguration(cls, sphinxConfiguration: Config) -> None:

129 from sphinx_reports import ReportDomain

130

131 variableName = f"{ReportDomain.name}_{cls.configPrefix}_levels"

132

133 try:

134 coverageLevelDefinitions: Dict[str, package_DictType] = sphinxConfiguration[f"{ReportDomain.name}_{cls.configPrefix}_levels"]

135 except (KeyError, AttributeError) as ex:

136 raise ReportExtensionError(f"Configuration option '{variableName}' is not configured.") from ex

137

138 if "default" not in coverageLevelDefinitions:

139 cls._coverageLevelDefinitions["default"] = cls.defaultCoverageDefinitions["default"]

140

141 for key, coverageLevelDefinition in coverageLevelDefinitions.items():

142 configurationName = f"conf.py: {variableName}:[{key}]"

143

144 if 100 not in coverageLevelDefinition:

145 raise ReportExtensionError(f"{configurationName}[100]: Configuration is missing.")

146 elif "error" not in coverageLevelDefinition:

147 raise ReportExtensionError(f"{configurationName}[error]: Configuration is missing.")

148

149 cls._coverageLevelDefinitions[key] = {}

150

151 for level, levelConfig in coverageLevelDefinition.items():

152 try:

153 if isinstance(level, str):

154 if level != "error":

155 raise ReportExtensionError(f"{configurationName}[{level}]: Level is a keyword, but not 'error'.")

156 elif not (0.0 <= int(level) <= 100.0):

157 raise ReportExtensionError(f"{configurationName}[{level}]: Level is out of range 0..100.")

158 except ValueError as ex:

159 raise ReportExtensionError(f"{configurationName}[{level}]: Level is not a keyword or an integer in range 0..100.") from ex

160

161 try:

162 cssClass = levelConfig["class"]

163 except KeyError as ex:

164 raise ReportExtensionError(f"{configurationName}[{level}].class: CSS class is missing.") from ex

165

166 try:

167 description = levelConfig["desc"]

168 except KeyError as ex:

169 raise ReportExtensionError(f"{configurationName}[{level}].desc: Description is missing.") from ex

170

171 cls._coverageLevelDefinitions[key][level] = {

172 "class": cssClass,

173 "desc": description

174 }

175

176 @classmethod

177 def _CheckPackagesConfiguration(cls, sphinxConfiguration: Config) -> None:

178 from sphinx_reports import ReportDomain

179

180 variableName = f"{ReportDomain.name}_{cls.configPrefix}_packages"

181

182 try:

183 allPackages: Dict[str, package_DictType] = sphinxConfiguration[f"{ReportDomain.name}_{cls.configPrefix}_packages"]

184 except (KeyError, AttributeError) as ex:

185 raise ReportExtensionError(f"Configuration option '{variableName}' is not configured.") from ex

186

187 # try:

188 # packageConfiguration = allPackages[self._reportID]

189 # except KeyError as ex:

190 # raise ReportExtensionError(f"conf.py: {ReportDomain.name}_{cls.configPrefix}_packages: No configuration found for '{self._reportID}'.") from ex

191

192 for reportID, packageConfiguration in allPackages.items():

193 configurationName = f"conf.py: {variableName}:[{reportID}]"

194

195 try:

196 packageName = packageConfiguration["name"]

197 except KeyError as ex:

198 raise ReportExtensionError(f"{configurationName}.name: Configuration is missing.") from ex

199

200 try:

201 jsonReport = Path(packageConfiguration["json_report"])

202 except KeyError as ex:

203 raise ReportExtensionError(f"{configurationName}.json_report: Configuration is missing.") from ex

204

205 if not jsonReport.exists():

206 raise ReportExtensionError(f"{configurationName}.json_report: Coverage report file '{jsonReport}' doesn't exist.") from FileNotFoundError(jsonReport)

207

208 try:

209 failBelow = int(packageConfiguration["fail_below"]) / 100

210 except KeyError as ex:

211 raise ReportExtensionError(f"{configurationName}.fail_below: Configuration is missing.") from ex

212 except ValueError as ex:

213 raise ReportExtensionError(f"{configurationName}.fail_below: '{packageConfiguration['fail_below']}' is not an integer in range 0..100.") from ex

214

215 if not (0.0 <= failBelow <= 100.0):

216 raise ReportExtensionError(f"{configurationName}.fail_below: Is out of range 0..100.")

217

218 try:

219 levels = packageConfiguration["levels"]

220 except KeyError as ex:

221 raise ReportExtensionError(f"{configurationName}.levels: Configuration is missing.") from ex

222

223 if isinstance(levels, str):

224 try:

225 levelDefinition = cls._coverageLevelDefinitions[levels]

226 except KeyError as ex:

227 raise ReportExtensionError(

228 f"{configurationName}.levels: Referenced coverage levels '{levels}' are not defined in conf.py variable '{variableName}'.") from ex

229 elif isinstance(levels, dict):

230 if 100 not in packageConfiguration["levels"]:

231 raise ReportExtensionError(f"{configurationName}.levels[100]: Configuration is missing.")

232 elif "error" not in packageConfiguration["levels"]:

233 raise ReportExtensionError(f"{configurationName}.levels[error]: Configuration is missing.")

234

235 levelDefinition = {}

236 for x, y in packageConfiguration["levels"].items():

237 pass

238 else:

239 raise ReportExtensionError(f"")

240

241 cls._packageConfigurations[reportID] = {

242 "name": packageName,

243 "json_report": jsonReport,

244 "fail_below": failBelow,

245 "levels": levelDefinition

246 }

247

248 def _ConvertToColor(self, currentLevel: float, configKey: str) -> str:

249 if currentLevel < 0.0:

250 return self._levels["error"][configKey]

251

252 for levelLimit, levelConfig in self._levels.items():

253 if isinstance(levelLimit, int) and (currentLevel * 100) < levelLimit:

254 return levelConfig[configKey]

255

256 return self._levels[100][configKey]

257

258

259@export

260class CodeCoverage(CodeCoverageBase):

261 """

262 This directive will be replaced by a table representing code coverage.

263 """

264 directiveName: str = "code-coverage"

265

266 has_content = False

267 required_arguments = 0

268 optional_arguments = CodeCoverageBase.optional_arguments + 1

269

270 option_spec = CodeCoverageBase.option_spec | {

271 "no-branch-coverage": flag

272 }

273

274 _noBranchCoverage: bool

275 _packageName: str

276 _jsonReport: Path

277 _failBelow: float

278 _coverage: PackageCoverage

279

280 def _CheckOptions(self) -> None:

281 """

282 Parse all directive options or use default values.

283 """

284 super()._CheckOptions()

285

286 self._noBranchCoverage = "no-branch-coverage" in self.options

287

288 try:

289 packageConfiguration = self._packageConfigurations[self._reportID]

290 except KeyError as ex:

291 raise ReportExtensionError(f"No configuration for '{self._reportID}'") from ex

292

293 self._packageName = packageConfiguration["name"]

294 self._jsonReport = packageConfiguration["json_report"]

295 self._failBelow = packageConfiguration["fail_below"]

296 self._levels = packageConfiguration["levels"]

297

298 def _GenerateCoverageTable(self) -> nodes.table:

299 cssClasses = ["report-codecov-table", f"report-codecov-{self._reportID}"]

300 cssClasses.extend(self._cssClasses)

301

302 # Create a table and table header with 10 columns

303 columns = [

304 ("Package", [(" Module", 500)], None),

305 ("Statments", [("Total", 100), ("Excluded", 100), ("Covered", 100), ("Missing", 100), ("Coverage", 100)], None),

306 ("Branches" , [("Total", 100), ("Covered", 100), ("Partial", 100), ("Missing", 100), ("Coverage", 100)], None),

307 # ("Coverage", [("in %", 100)], None)

308 ]

309

310 if self._noBranchCoverage:

311 columns.pop(2)

312

313 table, tableGroup = self._CreateTableHeader(

314 identifier=self._reportID,

315 columns=columns,

316 classes=cssClasses

317 )

318 tableBody = nodes.tbody()

319 tableGroup += tableBody

320

321 self.renderlevel(tableBody, self._coverage)

322

323 # Add a summary row

324 tableRow = nodes.row("", classes=[

325 "report-summary",

326 self._ConvertToColor(self._coverage.AggregatedStatementCoverage, "class")

327 ])

328 tableBody += tableRow

329

330 tableRow += nodes.entry("", nodes.paragraph(text=f"Overall ({self._coverage.FileCount} files):"))

331 tableRow += nodes.entry("", nodes.paragraph(text=f"{self._coverage.AggregatedTotalStatements}"))

332 tableRow += nodes.entry("", nodes.paragraph(text=f"{self._coverage.AggregatedExcludedStatements}"))

333 tableRow += nodes.entry("", nodes.paragraph(text=f"{self._coverage.AggregatedCoveredStatements}"))

334 tableRow += nodes.entry("", nodes.paragraph(text=f"{self._coverage.AggregatedMissingStatements}"))

335 tableRow += nodes.entry("", nodes.paragraph(text=f"{self._coverage.AggregatedStatementCoverage:.1%}"))

336 if not self._noBranchCoverage:

337 tableRow += nodes.entry("", nodes.paragraph(text=f"{self._coverage.AggregatedTotalBranches}"))

338 tableRow += nodes.entry("", nodes.paragraph(text=f"{self._coverage.AggregatedCoveredBranches}"))

339 tableRow += nodes.entry("", nodes.paragraph(text=f"{self._coverage.AggregatedPartialBranches}"))

340 tableRow += nodes.entry("", nodes.paragraph(text=f"{self._coverage.AggregatedMissingBranches}"))

341 tableRow += nodes.entry("", nodes.paragraph(text=f"{self._coverage.AggregatedBranchCoverage:.1%}"))

342

343 return table

344

345 def sortedValues(self, d: Mapping[str, Coverage]) -> Generator[Coverage, None, None]:

346 for key in sorted(d.keys()):

347 yield d[key]

348

349 def renderlevel(self, tableBody: nodes.tbody, packageCoverage: PackageCoverage, level: int = 0) -> None:

350 coverage = 1 if packageCoverage.Coverage < 0.0 else packageCoverage.Coverage

351 tableRow = nodes.row("", classes=[

352 "report-package",

353 self._ConvertToColor(coverage, "class")

354 ])

355 tableBody += tableRow

356

357 tableRow += nodes.entry("", nodes.paragraph(text=f"{' ' * level}📦{packageCoverage.Name}"))

358 tableRow += nodes.entry("", nodes.paragraph(text=f"{packageCoverage.TotalStatements}"))

359 tableRow += nodes.entry("", nodes.paragraph(text=f"{packageCoverage.ExcludedStatements}"))

360 tableRow += nodes.entry("", nodes.paragraph(text=f"{packageCoverage.CoveredStatements}"))

361 tableRow += nodes.entry("", nodes.paragraph(text=f"{packageCoverage.MissingStatements}"))

362 tableRow += nodes.entry("", nodes.paragraph(text=f"{packageCoverage.StatementCoverage:.1%}"))

363 if not self._noBranchCoverage:

364 tableRow += nodes.entry("", nodes.paragraph(text=f"{packageCoverage.TotalBranches}"))

365 tableRow += nodes.entry("", nodes.paragraph(text=f"{packageCoverage.CoveredBranches}"))

366 tableRow += nodes.entry("", nodes.paragraph(text=f"{packageCoverage.PartialBranches}"))

367 tableRow += nodes.entry("", nodes.paragraph(text=f"{packageCoverage.MissingBranches}"))

368 tableRow += nodes.entry("", nodes.paragraph(text=f"{packageCoverage.BranchCoverage:.1%}"))

369

370 for package in self.sortedValues(packageCoverage._packages):

371 self.renderlevel(tableBody, package, level + 1)

372

373 for module in self.sortedValues(packageCoverage._modules):

374 tableRow = nodes.row("", classes=[

375 "report-module",

376 self._ConvertToColor(module.Coverage, "class")

377 ])

378 tableBody += tableRow

379

380 tableRow += nodes.entry("", nodes.paragraph(text=f"{' ' * (level + 1)} ⚙️{module.Name}"))

381 tableRow += nodes.entry("", nodes.paragraph(text=f"{module.TotalStatements}"))

382 tableRow += nodes.entry("", nodes.paragraph(text=f"{module.ExcludedStatements}"))

383 tableRow += nodes.entry("", nodes.paragraph(text=f"{module.CoveredStatements}"))

384 tableRow += nodes.entry("", nodes.paragraph(text=f"{module.MissingStatements}"))

385 tableRow += nodes.entry("", nodes.paragraph(text=f"{module.StatementCoverage:.1%}"))

386 if not self._noBranchCoverage:

387 tableRow += nodes.entry("", nodes.paragraph(text=f"{module.TotalBranches}"))

388 tableRow += nodes.entry("", nodes.paragraph(text=f"{module.CoveredBranches}"))

389 tableRow += nodes.entry("", nodes.paragraph(text=f"{module.PartialBranches}"))

390 tableRow += nodes.entry("", nodes.paragraph(text=f"{module.MissingBranches}"))

391 tableRow += nodes.entry("", nodes.paragraph(text=f"{module.BranchCoverage:.1%}"))

392

393 def _CreatePages(self) -> None:

394 def handlePackage(package: PackageCoverage) -> None:

395 for pack in package._packages.values():

396 if handlePackage(pack):

397 return

398

399 for module in package._modules.values():

400 if handleModule(module):

401 return

402

403 def handleModule(module: ModuleCoverage) -> None:

404 doc = new_document("dummy")

405

406 rootSection = nodes.section(ids=["foo"])

407 doc += rootSection

408

409 title = nodes.title(text=f"{module.Name}")

410 rootSection += title

411 rootSection += nodes.paragraph(text="some text")

412

413 docname = f"coverage/{module.Name}"

414 self.env.titles[docname] = title

415 self.env.longtitles[docname] = title

416

417 return

418

419 handlePackage(self._coverage)

420

421 def run(self) -> List[nodes.Node]:

422 container = nodes.container()

423

424 try:

425 self._CheckOptions()

426 except ReportExtensionError as ex:

427 message = f"Caught {ex.__class__.__name__} when checking options for directive '{self.directiveName}'."

428 return self._internalError(container, __name__, message, ex)

429

430 # Assemble a list of Python source files

431 analyzer = Analyzer(self._packageName, self._jsonReport)

432 self._coverage = analyzer.Convert()

433 # self._coverage.Aggregate()

434

435 self._CreatePages()

436

437 container += self._GenerateCoverageTable()

438

439 def foo():

440 docName = self.env.docname

441 docParent = docName[:docName.rindex("/")]

442

443 subnode = toctree()

444 subnode['parent'] = docName

445

446 # (title, ref) pairs, where ref may be a document, or an external link,

447 # and title may be None if the document's title is to be used

448 subnode['entries'] = []

449 subnode['includefiles'] = []

450 subnode['maxdepth'] = -1 # self.options.get('maxdepth', -1)

451 subnode['caption'] = None # self.options.get('caption')

452 subnode['glob'] = None # 'glob' in self.options

453 subnode['hidden'] = True # 'hidden' in self.options

454 subnode['includehidden'] = False # 'includehidden' in self.options

455 subnode['numbered'] = 0 # self.options.get('numbered', 0)

456 subnode['titlesonly'] = False # 'titlesonly' in self.options

457 self.set_source_info(subnode)

458

459 wrappernode = nodes.compound(classes=['toctree-wrapper'])

460 wrappernode.append(subnode)

461 self.add_name(wrappernode)

462

463 for entry in (

464 "sphinx_reports",

465 "sphinx_reports.Adapter",

466 "sphinx_reports.Adapter.Coverage",

467 "sphinx_reports.Adapter.DocStrCoverage",

468 "sphinx_reports.Adapter.JUnit",

469 "sphinx_reports.DataModel",

470 "sphinx_reports.DataModel.CodeCoverage",

471 "sphinx_reports.DataModel.DocumentationCoverage",

472 "sphinx_reports.DataModel.Unittest",

473 "sphinx_reports.static",

474 "sphinx_reports.CodeCoverage",

475 "sphinx_reports.Common",

476 "sphinx_reports.DocCoverage",

477 "sphinx_reports.Sphinx",

478 "sphinx_reports.Unittest",

479 ):

480 moduleDocumentName = f"{docParent}/{entry}"

481 moduleDocumentTitle = entry

482

483 subnode["entries"].append((moduleDocumentTitle, moduleDocumentName))

484 subnode["includefiles"].append(moduleDocumentName)

485

486 return [container] #, wrappernode]

487

488

489@export

490class CodeCoverageLegend(CodeCoverageBase):

491 """

492 This directive will be replaced by a legend table representing coverage levels.

493 """

494 has_content = False

495 required_arguments = 0

496 optional_arguments = CodeCoverageBase.optional_arguments + 1

497

498 option_spec = CodeCoverageBase.option_spec | {

499 "style": stripAndNormalize

500 }

501

502 directiveName: str = "code-coverage-legend"

503

504 _style: LegendStyle

505

506 def _CheckOptions(self) -> None:

507 # Parse all directive options or use default values

508 super()._CheckOptions()

509

510 self._style = self._ParseLegendStyle("style", LegendStyle.horizontal_table)

511

512 try:

513 packageConfiguration = self._packageConfigurations[self._reportID]

514 except KeyError as ex:

515 raise ReportExtensionError(f"No configuration for '{self._reportID}'") from ex

516

517 self._levels = packageConfiguration["levels"]

518

519 def _CreateHorizontalLegendTable(self, identifier: str, classes: List[str]) -> nodes.table:

520 columns = [("Code Coverage:", None, 300)]

521 for level in self._levels:

522 if isinstance(level, int):

523 columns.append((f"≤{level} %", None, 200))

524

525 table, tableGroup = self._CreateTableHeader(columns, identifier=identifier, classes=classes)

526 tableBody = nodes.tbody()

527 tableGroup += tableBody

528

529 legendRow = nodes.row("", classes=["report-codecov-legend-row"])

530 legendRow += nodes.entry("", nodes.paragraph(text="Coverage Level:"))

531 tableBody += legendRow

532 for level, config in self._levels.items():

533 if isinstance(level, int):

534 legendRow += nodes.entry("", nodes.paragraph(text=config["desc"]), classes=[self._ConvertToColor((level - 1) / 100, "class")])

535

536 legendRow = nodes.row("", classes=["report-codecov-legend-row"])

537 legendRow += nodes.entry("", nodes.paragraph(text="Coverage Level:"))

538 tableBody += legendRow

539 for level, config in self._levels.items():

540 if isinstance(level, int):

541 legendRow += nodes.entry("", nodes.paragraph(text=config["desc"]), classes=[self._ConvertToColor((level - 1) / 100, "class")])

542

543 return table

544

545 def _CreateVerticalLegendTable(self, identifier: str, classes: List[str]) -> nodes.table:

546 table, tableGroup = self._CreateTableHeader([

547 ("Code Coverage", None, 300),

548 ("Coverage Level", None, 300)

549 ],

550 identifier=identifier,

551 classes=classes

552 )

553

554 tableBody = nodes.tbody()

555 tableGroup += tableBody

556

557 for level, config in self._levels.items():

558 if isinstance(level, int):

559 tableBody += nodes.row(

560 "",

561 nodes.entry("", nodes.paragraph(text=f"≤{level} %")),

562 nodes.entry("", nodes.paragraph(text=config["desc"])),

563 classes=["report-codecov-legend-row", self._ConvertToColor((level - 1) / 100, "class")]

564 )

565

566 return table

567

568 def run(self) -> List[nodes.Node]:

569 container = nodes.container()

570

571 try:

572 self._CheckOptions()

573 except ReportExtensionError as ex:

574 message = f"Caught {ex.__class__.__name__} when checking options for directive '{self.directiveName}'."

575 return self._internalError(container, __name__, message, ex)

576

577 if LegendStyle.Table in self._style:

578 if LegendStyle.Horizontal in self._style:

579 container += self._CreateHorizontalLegendTable(identifier=f"{self._reportID}-legend", classes=["report-codecov-legend"])

580 elif LegendStyle.Vertical in self._style:

581 container += self._CreateVerticalLegendTable(identifier=f"{self._reportID}-legend", classes=["report-codecov-legend"])

582 else:

583 container += nodes.paragraph(text=f"Unsupported legend style.")

584 else:

585 container += nodes.paragraph(text=f"Unsupported legend style.")

586

587 return [container]

588

589

590

591@export

592class ModuleCoverage(CodeCoverageBase):

593 """

594 This directive will be replaced by highlighted source code.

595 """

596 directiveName: str = "module-coverage"

597

598 has_content = False

599 required_arguments = 0

600 optional_arguments = 2

601

602 option_spec = CodeCoverageBase.option_spec | {

603 "module": stripAndNormalize

604 }

605

606 _packageName: str

607 _moduleName: str

608 _jsonReport: Path

609

610 def _CheckOptions(self) -> None:

611 """

612 Parse all directive options or use default values.

613 """

614 super()._CheckOptions()

615

616 self._moduleName = self._ParseStringOption("module")

617

618 try:

619 packageConfiguration = self._packageConfigurations[self._reportID]

620 except KeyError as ex:

621 raise ReportExtensionError(f"No configuration for '{self._reportID}'") from ex

622

623 self._packageName = packageConfiguration["name"]

624 self._jsonReport = packageConfiguration["json_report"]

625

626 def run(self) -> List[nodes.Node]:

627 container = nodes.container()

628

629 try:

630 self._CheckOptions()

631 except ReportExtensionError as ex:

632 message = f"Caught {ex.__class__.__name__} when checking options for directive '{self.directiveName}'."

633 return self._internalError(container, __name__, message, ex)

634

635 # Assemble a list of Python source files

636 analyzer = Analyzer(self._packageName, self._jsonReport)

637 self._coverage = analyzer.Convert()

638

639 sourceFile = "../../sphinx_reports/__init__.py"

640

641 container += nodes.paragraph(text=f"Code coverage of {self._moduleName}")

642

643 # lexer = get_lexer_by_name("python", tabsize=2)

644 # tokens = lex(code, lexer)

645

646 # htmlFormatter = HtmlFormatter(linenos=True, cssclass="source")

647 # highlight()

648

649 location = self.state_machine.get_source_and_line(self.lineno)

650 rel_filename, filename = self.env.relfn2path(sourceFile)

651 self.env.note_dependency(rel_filename)

652

653 reader = LiteralIncludeReader(filename, {"tab-width": 2}, self.config)

654 text, lines = reader.read(location=location)

655

656 literalBlock: nodes.Element = nodes.literal_block(text, text, source=filename)

657 literalBlock["language"] = "codecov"

658 literalBlock['highlight_args'] = extra_args = {}

659 extra_args['hl_lines'] = [i for i in range(10, 20)]

660 self.set_source_info(literalBlock)

661

662 container += literalBlock

663

664 return [container]