Rules Score Doc

Usage

  • Skills Setup
  • User Guide
    • General Information
      • The Dependable Element Concept
      • Architecture Overview
      • Getting Started
      • Rule Reference dependable_element
      • Automatic Validations
        • Architecture consistency
        • Certified scope
        • Integrity level
    • Tutorial: Your First Dependable Element
      • Step 0 — Setup
        • BUILD
      • Step 1 — Requirements
        • Assumed System Requirements
        • Feature Requirements
        • BUILD
      • Step 2 — SW Architectural Design
        • static_design.puml
        • BUILD
      • Step 3 — Unit Design
        • class_design.puml
        • src/my_unit.h
        • src/my_unit.cpp
        • BUILD
      • Step 4 — Validation
        • src/my_unit_test.cpp
        • BUILD
      • Step 5 — Build
        • Running Validations
    • Requirements
      • Requirement Hierarchy & Traceability
      • Writing Good Requirements
        • Sentence template
        • Quality criteria
        • Choosing the level
        • Refining a parent into children
      • Modeling Requirements
        • Assumed System Requirements
        • Feature Requirements
        • Component Requirements
      • Validation
      • Adding Images and Diagrams to Requirement Descriptions
      • Allocation of Requirements to Architectural Elements
      • AI-Powered Quality Check
        • trlc_requirements_ai_test
      • Modeling Requirements in Bazel Rules
    • Assumptions of Use
      • AoU Forwarding
    • Architectural Design
      • Declared vs. Implemented Architecture
      • Overview and Hierarchy
      • Determining Components and Units
        • What makes a unit
        • What makes a component
        • Deciding the boundaries
        • Public vs. internal interfaces
        • Common anti-patterns
      • Rendering: Diagrams, Wrapper Pages, and Directory Navigation
        • Authoring pages alongside diagrams
      • Static Architecture
        • PlantUML
          • Valid PlantUML Definitions
          • Interface Bindings
          • Named Ports (alternative)
        • Bazel
          • architectural_design
          • unit
          • component
      • Dynamic Architecture
        • PlantUML
        • Bazel
      • Public API
        • PlantUML
        • Bazel
      • Internal API
        • PlantUML
        • Bazel
      • RST and Markdown Wrappers
      • Rule Reference: architectural_design
    • Software Unit Design
      • Designing the internals of a unit
      • unit_design — Code-Level Design Diagrams
        • PlantUML
        • Implementation
        • Bazel
      • unit_design Rule Reference
    • Dependability Analysis
      • Overview
        • Why safety analysis?
        • How FMEA works
        • Fault models
      • Performing the Analysis
        • Step 1 — Identify failure modes per interface
        • Step 2 — Analyse the effect, then decompose to causes
        • Step 3 — Choose a countermeasure for every root cause
      • Bazel Rule dependability_analysis
      • FMEA
        • Failure Modes (TRLC)
        • FTA Diagrams (PlantUML)
          • Available procedures
          • Linking procedures together
          • Example FTA diagram
        • Control Measures (TRLC)
          • Other measure types
        • fmea — Bazel Rule
      • Traceability Validation
      • Example
    • Validation
      • Unit Tests
        • Annotating Tests
        • Stating Coverage for test cases
  • Rule Reference
    • Documentation Rules
      • sphinx_module
      • filter_execpath
    • Artifact Rules
      • assumed_system_requirements
      • feature_requirements
      • component_requirements
      • assumptions_of_use
      • glossary
      • architectural_design
      • unit_design
      • fmea
      • dependability_analysis
    • Structural Rules
      • unit
      • component
      • dependable_element

Examples

  • Minimal
  • Other Library
  • SEooC
  • Integrator

Validation

  • Bazel Component Specification
    • Purpose
    • What is Validated
      • Dependable Element Consistency
      • Component Consistency
      • Unit Consistency
      • Parent Context
      • Bazel Label Format Validation
      • Duplicate Entity Detection
      • Parent Reference Validity
      • Non-Empty Composition
    • Failure Cases
    • PlantUML Stereotype Reference
    • Debug Output
  • Class Design Implementation Specification
    • Purpose
    • What is Validated
      • Entity Presence and Type Consistency
      • Template Parameter Consistency
      • Type Alias Consistency
      • Variable Consistency
      • Method Consistency
      • Enum Literal Consistency
      • Relationship Consistency
      • Type Normalization
    • Failure Cases
    • Debug Output
  • Component Internal API Specification
    • Purpose
    • What is Validated
      • Interface Declaration Consistency
    • Failure Cases
    • Debug Output
  • Component Public API Specification
    • Purpose
    • What is Validated
      • Interface Declaration Consistency
      • SEooC Relationship Consistency
    • Failure Cases
    • Debug Output
  • Component Sequence Specification
    • Purpose
    • What is Validated
      • Alias Consistency
      • Interface-Connection Consistency
    • Failure Cases
    • Debug Output
  • Sequence Internal API Specification
    • Purpose
    • What is Validated
      • Method-Name Consistency
      • Consumer/Provider Role Consistency
      • Interface Coverage
    • Failure Cases
    • Debug Output

Development

  • Integration Guide
    • Build Flow
    • Toolchain Setup
      • Adding extensions
      • Diagnosing which toolchain won
      • Replacing the dependency set entirely
      • Assembling a toolchain by hand
    • Cross-module dependencies
    • Complete Example
    • Design Rationale
    • Staged Layout of architectural_design Output
    • Hermetic Diagram Tools (Graphviz and PlantUML)
      • Graphviz / dot
      • PlantUML
  • Architecture
    • Three layers
    • Rule → tool invocation map
    • Tool inventory
    • How the tools interrelate — the traceability data flow
    • Lobster report assembly (dependable_element)
    • Two-phase Sphinx build
      • Phase 1 — <name>_needs
      • Phase 2 — <name>
    • Safety analysis document pipeline
    • Hermetic tool path resolution
      • Background: Bazel action environment
      • What the rule passes
      • How conf.template.py resolves the paths
      • Why rlocation alone cannot resolve the binary
      • The exec_in_sysroot wrapper’s own runfiles bootstrap
      • PlantUML and the hermetic dot
  • Tool Reference
    • Manual Analysis
      • Context Providers
        • manual_analysis_context_from_filegroup
        • manual_analysis_context_from_cc_library
        • Custom context-provider rules
      • Analysis YAML Schema
      • Typical Workflow
        • 1. Define context and analysis in BUILD
        • 2. Perform the interactive analysis
        • Interactive UI
        • 3. Commit the generated files
        • 4. Verify in CI
      • LOBSTER Integration
      • Example
    • AI Checker
      • User Guide
        • What It Does
        • Prerequisites
        • Running a Check
        • Rule Reference
          • trlc_requirements_ai_test
          • architecture_ai_test
        • Output
        • Debug Output
        • Custom AI Model
      • Integration Guide
        • Step 1 — Provide Credentials
        • Step 2 — Declare Bazel Targets
        • Guidelines
        • Project-Specific Guidelines (set once)
        • Custom AI Model (Bazel)
        • Debug Output
      • Developer Guide
    • TRLC
    • PlantUML Parser
      • What It Does
      • Usage
        • Build:
        • Run:
      • Architecture
    • Validation Core
      • What It Validates
      • Layering
      • Inputs
      • Run
      • Architectural Overview
    • Clickable PlantUML
      • Concept: From .puml Source to Clickable Diagram
      • Sphinx Integration
      • How It Works
      • Automatic idmap Generation (Bazel)
        • Role detection algorithm
        • Concrete example
      • idmap Format
      • End-to-End Clickable Diagram Example
    • Bazel
    • Scope Check
      • Declaring scope
      • What is checked
      • Implementation
    • Lobster Bazel (Source Tracing)
      • Adding tracing tags to source files
      • Creating lobster files
        • Error behaviour
      • Bazel integration
    • LOBSTER
    • Test Case Coverage (test_case_coverage)
      • Two phases
      • Architecture
      • Data flow
      • Lock file format

Tool Qualification

  • Requirements
    • Requirements
      • Use Cases
        • Use Cases
      • Potential Errors
        • Potential Errors
          • Documentation Build
          • Requirement Traceability
          • Safety Analysis
          • Architecture
          • AoU Forwarding
      • Tool Requirements
        • Tool Requirements
          • Requirements Rendering
          • Requirement Validation
          • Safety Analysis Rendering
          • Architecture Parsing
          • Lobster Traceability
          • AoU Forwarding
          • Test Case Coverage
      • Validation Core Requirements
        • Tool Requirements
          • Validation Core
            • Bazel Component Validator
            • Component Sequence Validator
            • Sequence Internal API Validator
            • Component Internal API Validator
            • Component Public API Validator
            • Class Design Implementation Validator
            • Class Design Sequence Validator
  • Traceability Report
    • Overview
    • Use Cases
    • Potential Errors
    • Tool Requirements
    • Code
  • Quality Report
    • Code Coverage
Rules Score Doc
  • User Guide
  • View page source

User Guide

Overview

  • General Information
    • The Dependable Element Concept
    • Architecture Overview
    • Getting Started
    • Rule Reference dependable_element
    • Automatic Validations

Tutorial

  • Tutorial: Your First Dependable Element

Guides

  • Requirements
    • Requirement Hierarchy & Traceability
    • Writing Good Requirements
    • Modeling Requirements
    • Validation
    • Adding Images and Diagrams to Requirement Descriptions
    • Allocation of Requirements to Architectural Elements
    • AI-Powered Quality Check
    • Modeling Requirements in Bazel Rules
  • Assumptions of Use
    • AoU Forwarding
  • Architectural Design
    • Declared vs. Implemented Architecture
    • Overview and Hierarchy
    • Determining Components and Units
    • Rendering: Diagrams, Wrapper Pages, and Directory Navigation
    • Static Architecture
    • Dynamic Architecture
    • Public API
    • Internal API
    • RST and Markdown Wrappers
    • Rule Reference: architectural_design
  • Software Unit Design
    • Designing the internals of a unit
    • unit_design — Code-Level Design Diagrams
    • unit_design Rule Reference
  • Dependability Analysis
    • Overview
    • Performing the Analysis
    • Bazel Rule dependability_analysis
    • FMEA
    • Traceability Validation
    • Example
  • Validation
    • Unit Tests
Previous Next

© Copyright .

Built with Sphinx using a theme provided by Read the Docs.