Quality: 169 tests: 169 passed, 0 failed, 0 skipped, 6 of 13 requirements proved, 51 findings held, 0 open issues, 0 open tickets. The tests and issues of the library
Mizan, the IF Spec Profile, as code (commons 0003-mizan ): the rules a specification is held to as plugins of one harness (rules.ts, harness.ts), the levels of conformance (levels.ts), the standards rules about terms (standards.ts, spec-terms.ts), the integrations of standards (integrations/, commons 0019-mizan-integrations ), the change-control rules (changes/, commons 0020-ifccm ) and the release rules (versions/, commons 0026-works-versioning ) as plugins of the same harness, the trace of requirements to code and tests and the layers of a ladder (trace.ts, layers.ts, commons 0015-trace ), The commands that need the whole repository (check, versions, changes, libraries, the generators of ontologies and the register) are the repository's.
# Entry points# Modules# LimitsWhat the modules of this area do not do, or do only in part, as each module's @limits says.
changes/capability-trace.ts
src/changes/capability-trace.ts
It reads text, not syntax, as kernel/trace.ts does; the files it reads are those of the tree it is given, so a file a commit deleted is not a link; and a capability is only what a commit names, so work that no commit refers to is listed apart (unreferenced) and in no capability.
changes/commit-message.ts
src/changes/commit-message.ts
It does not ask whether an issue exists or is closed (strict.ts does, through the host interface) and does not read trailers other than Departs:, Decision: and Impact:.
changes/declaration.ts
src/changes/declaration.ts
It does not read Git: git-log.ts gives it the versions. A role is the name a harness gives; no standard of roles is adopted (0020-ifccm FR-020 asks only that two roles differ).
changes/git-log.ts
src/changes/git-log.ts
It reads one repository and no remote: what a host says of an issue is strict.ts's, through the host interface.
changes/issue-body.ts
src/changes/issue-body.ts
It does not decide that a Done when is met: a person ticks it, and the check only reads whether it is ticked.
changes/rules.ts
src/changes/rules.ts
It judges the words of a message and a body, not whether the work done is what the issue asked.
changes/strict.ts
src/changes/strict.ts
It asks about issues only; a pull request or a merge request is read as part of a change, never as a change request (FR-029), and #N means the issue.
changes/terms-file.ts
src/changes/terms-file.ts
A module is run, as any module is: it is the harness's own file, named by the harness on its command line. It reads no ontology other than the one it is given.
changes/trace.ts
src/changes/trace.ts
It reads text, not syntax (as kernel/trace.ts does), and judges the cases it is given: which run, at which revision, is the caller's.
pure/export-dcat.ts
src/integrations/pure/export-dcat.ts
No dcat:byteSize and no checksum (they would make the catalog depend on the bytes of the files it describes, which are generated in the same run); no dcat:DataService, no theme, keyword or spatial and temporal coverage; the publisher is named, not described further. An IRI that does not parse, or a media type with no /, is a finding.
pure/export-owl.ts
src/integrations/pure/export-owl.ts
No restriction, disjointness, equivalence, cardinality or property characteristic: the typed schemas do not state them (the fields of OwlClass, ObjectProperty and DatatypeProperty are the label, comment, definition, superclasses, domain and range). The individuals (rungs, authorities) are data, exported as RDF, not as OWL axioms. No independent reader of functional syntax is a pinned dependency of the suite; the form is held to the OWL 2 functional-syntax grammar by hand and by a reader of its axioms in the root test (commons-mizan-ontology.test.ts), which compares them with the Turtle graph.
pure/export-rdfxml.ts
src/integrations/pure/export-rdfxml.ts
ASCII names only for a predicate's local name; no rdf:parseType, no nested node elements and no rdf:ID (the graph, not the shorthand, is what is exported), and no typed node elements (<mz:Rung rdf:about=...>), as a subject of several types has no canonical one.
pure/export.ts
src/integrations/pure/export.ts
Not yet written: OWL, RDF/XML, SSSOM mappings (the term schema does not yet say which relation a mapping is) and the DCAT entry. The JSON Schema is checked here by its own structure; an independent validator reads it in a test only when one is a dependency of the suite.
pure/import-json-schema.ts
src/integrations/pure/import-json-schema.ts
What a typed union of names cannot hold is named, per definition, as an unsupported finding and never dropped silently: composition (anyOf and oneOf of schemas that are not constants; allOf of objects and $refs is merged, not lost), patternProperties, additionalProperties as a schema, propertyNames, dependent and conditional keywords (dependentSchemas, if), not, a $ref that is not into #/$defs/, a schema of another draft (its $defs or definitions are read as 2020-12's), and the value constraints (pattern, format, bounds, lengths). Annotations (title, description, default, examples) are not carried: they are prose a person reads in the schema. A definition with nothing to hold ends the import.
pure/import-oscal-catalog.ts
src/integrations/pure/import-oscal-catalog.ts
It keeps no statements, parameters, guidance or assessment objectives, which are prose a person reads in the catalog; it carries identifiers and titles only.
pure/import-vocabulary.ts
src/integrations/pure/import-vocabulary.ts
It states each term's class only. It carries no labels, comments, domains or ranges, which a harness states about the terms it uses in its own ontology.
pure/read-json-ld.ts
src/integrations/pure/read-json-ld.ts
It does not fetch a context, does not compact, frame or flatten, and keeps no named graph. A number's datatype follows its text (no . or e: xsd:integer, else xsd:double).
pure/read-rdf-xml.ts
src/integrations/pure/read-rdf-xml.ts
It does not validate against a DTD, does not fetch an external entity, keeps no XML literal, and reads UTF-8 text (the caller decodes). It reads no rdf:bagID (removed from the RDF/XML grammar). A property attribute without a namespace is an unsupported finding.
pure/read-rdf.ts
src/integrations/pure/read-rdf.ts
It does not resolve relative IRIs against a base beyond @base joined as text, does not read RDF/XML, JSON-LD or TriG, and keeps no blank-node structure.
src/layers.ts
src/layers.ts
It reads relative imports only: a package by its name is another repository's ladder. It reads the text, not the syntax tree.
src/levels.ts
src/levels.ts
It does not read a harness's declaration or a library's manifest (libraries.ts), and it does not run a rule: holdHarness asks it which rules to run.
src/standards.ts
src/standards.ts
It reads the records a harness gives it: whether a harness's own decision record exists is that harness's to say (the decision field is true where a Decision is linked).
src/trace.ts
src/trace.ts
It reads TypeScript's text, not its syntax tree: a requirement built at run time (FR(3)) is not read, and a proves( inside a string is. It runs no test.
versions/cite.ts
src/versions/cite.ts
It does not read Git: the day is an argument. It does not validate the file against the CFF schema, which is outside the repository's tools.
versions/git.ts
src/versions/git.ts
It does not verify a signature (it reports whether a tag carries one), does not contact a remote and does not move or delete a tag: createTag only creates.
versions/judge.ts
src/versions/judge.ts
It reads no Git: git.ts gives it the facts. A base whose record does not decode is a base that says nothing, and the work is judged by its head alone.
versions/ledger.ts
src/versions/ledger.ts
It does not verify a signature: signed says the tag carries one, and a person verifies with git tag -v and the keys they trust. It does not read Git.
versions/notes.ts
src/versions/notes.ts
It does not read Git, and does not ask whether an issue is closed on a host: the commits' words are the record.
versions/record.ts
src/versions/record.ts
It does not read Git, and does not judge a record against an earlier one (judge.ts). A person or agent that edits a record by hand is outside what it can prevent: the check finds the result.
versions/scheme.ts
src/versions/scheme.ts
It does not read a record or a tag, and does not say whether a commit exists: record.ts, judge.ts and git.ts do.