chore: Include OWNERS info in generated readme

Signed-off-by: Giulio Frasca <[email protected]>

Author: gmfrasca

scripts/generate_readme/content_generator.py

@@ -22,7 +22,8 @@ def __init__(self, metadata: Dict[str, Any], source_dir: Path):
         self.source_dir = source_dir
         self.metadata_file = source_dir / 'metadata.yaml'
         self.example_file = source_dir / 'example_pipeline.py'
-        self.yaml_metadata = self._load_yaml_metadata()
+        self.owners_file = source_dir / 'OWNERS'
+        self.feature_metadata = self._load_feature_metadata()
 
         # Set up Jinja2 environment
         template_dir = Path(__file__).parent
@@ -33,11 +34,14 @@ def __init__(self, metadata: Dict[str, Any], source_dir: Path):
         )
         self.template = self.env.get_template('README.md.j2')
 
-    def _load_yaml_metadata(self) -> Dict[str, Any]:
-        """Load and parse the metadata.yaml file, excluding the 'ci' field.
+    def _load_feature_metadata(self) -> Dict[str, Any]:
+        """Load and parse feature metadata from metadata.yaml and OWNERS files.
+        
+        Loads metadata from metadata.yaml (excluding 'ci' field) and augments it
+        with owners information from OWNERS file if it exists.
         
         Returns:
-            Dictionary containing the YAML metadata without the 'ci' field.
+            Dictionary containing the aggregated feature metadata.
         """
         try:
             with open(self.metadata_file, 'r', encoding='utf-8') as f:
@@ -47,10 +51,33 @@ def _load_yaml_metadata(self) -> Dict[str, Any]:
             if yaml_data and 'ci' in yaml_data:
                 yaml_data.pop('ci')
 
-            return yaml_data or {}
+            yaml_data = yaml_data or {}
         except Exception as e:
             logger.warning(f"Could not load metadata.yaml: {e}")
-            return {}
+            yaml_data = {}
+        
+        # Augment with owners information from OWNERS file
+        owners_data = self._load_owners()
+        if owners_data:
+            yaml_data['owners'] = owners_data
+        
+        return yaml_data
+    
+    def _load_owners(self) -> Dict[str, Any]:
+        """Load the OWNERS file if it exists.
+        
+        Returns:
+            Dictionary containing owners data (approvers and reviewers) if file exists, empty dict otherwise.
+        """
+        if self.owners_file.exists():
+            try:
+                with open(self.owners_file, 'r', encoding='utf-8') as f:
+                    owners_data = yaml.safe_load(f)
+                return owners_data or {}
+            except Exception as e:
+                logger.warning(f"Error reading OWNERS file ({self.owners_file}): {e}")
+                return {}
+        return {}
 
     def _load_example_pipeline(self) -> str:
         """Load the Example Pipeline file if it exists.
@@ -157,7 +184,7 @@ def _format_metadata(self) -> Dict[str, str]:
         """
         return {
             self._format_key(key): self._format_value(value)
-            for key, value in self.yaml_metadata.items()
+            for key, value in self.feature_metadata.items()
         }
 
     def generate_readme(self) -> str:
@@ -211,7 +238,7 @@ def _prepare_template_context(self) -> Dict[str, Any]:
         example_code = self._load_example_pipeline()
 
         # Prepare formatted metadata for human-readable display
-        formatted_metadata = self._format_metadata() if self.yaml_metadata else {}
+        formatted_metadata = self._format_metadata() if self.feature_metadata else {}
 
         return {
             'title': title,

scripts/generate_readme/tests/test_content_generator.py

@@ -18,7 +18,7 @@ def test_init_with_component(self, component_dir, sample_extracted_metadata):
         )
 
         assert generator.metadata == sample_extracted_metadata
-        assert generator.yaml_metadata is not None
+        assert generator.feature_metadata is not None
 
     def test_init_with_pipeline(self, pipeline_dir, sample_extracted_metadata):
         """Test initialization with pipeline metadata."""
@@ -29,18 +29,18 @@ def test_init_with_pipeline(self, pipeline_dir, sample_extracted_metadata):
 
         assert generator.metadata == sample_extracted_metadata
 
-    def test_load_yaml_metadata(self, component_dir, sample_extracted_metadata):
+    def test_load_feature_metadata(self, component_dir, sample_extracted_metadata):
         """Test loading YAML metadata from file."""
         generator = ReadmeContentGenerator(
             sample_extracted_metadata,
             component_dir
         )
 
-        assert 'name' in generator.yaml_metadata
-        assert generator.yaml_metadata['name'] == 'sample_component'
-        assert 'tier' in generator.yaml_metadata
+        assert 'name' in generator.feature_metadata
+        assert generator.feature_metadata['name'] == 'sample_component'
+        assert 'tier' in generator.feature_metadata
 
-    def test_load_yaml_metadata_excludes_ci(self, temp_dir, sample_extracted_metadata):
+    def test_load_feature_metadata_excludes_ci(self, temp_dir, sample_extracted_metadata):
         """Test that 'ci' field is excluded from YAML metadata."""
         metadata_file = temp_dir / "metadata.yaml"
         metadata_file.write_text("""name: test
@@ -55,9 +55,69 @@ def test_load_yaml_metadata_excludes_ci(self, temp_dir, sample_extracted_metadat
             temp_dir
         )
 
-        assert 'ci' not in generator.yaml_metadata
-        assert 'name' in generator.yaml_metadata
-        assert 'tier' in generator.yaml_metadata
+        assert 'ci' not in generator.feature_metadata
+        assert 'name' in generator.feature_metadata
+        assert 'tier' in generator.feature_metadata
+    
+    def test_load_owners_file_exists(self, component_dir, sample_extracted_metadata):
+        """Test loading OWNERS file when it exists."""
+        # Create an OWNERS file
+        owners_file = component_dir / "OWNERS"
+        owners_file.write_text("""approvers:
+  - user1
+  - user2
+reviewers:
+  - user3
+  - user4
+""")
+        
+        generator = ReadmeContentGenerator(
+            sample_extracted_metadata,
+            component_dir
+        )
+        
+        # Check that owners were loaded into feature_metadata
+        assert 'owners' in generator.feature_metadata
+        assert 'approvers' in generator.feature_metadata['owners']
+        assert 'reviewers' in generator.feature_metadata['owners']
+        assert generator.feature_metadata['owners']['approvers'] == ['user1', 'user2']
+        assert generator.feature_metadata['owners']['reviewers'] == ['user3', 'user4']
+    
+    def test_load_owners_file_not_exists(self, component_dir, sample_extracted_metadata):
+        """Test that missing OWNERS file doesn't cause errors."""
+        generator = ReadmeContentGenerator(
+            sample_extracted_metadata,
+            component_dir
+        )
+        
+        # Should not have owners in feature_metadata when OWNERS doesn't exist
+        assert 'owners' not in generator.feature_metadata
+    
+    def test_owners_in_generated_readme(self, component_dir, sample_extracted_metadata):
+        """Test that OWNERS data appears in generated README."""
+        # Create an OWNERS file
+        owners_file = component_dir / "OWNERS"
+        owners_file.write_text("""approvers:
+  - alice
+  - bob
+reviewers:
+  - charlie
+""")
+        
+        generator = ReadmeContentGenerator(
+            sample_extracted_metadata,
+            component_dir
+        )
+        
+        readme = generator.generate_readme()
+        
+        # Check that owners appear in the README
+        assert 'Owners' in readme
+        assert 'alice' in readme
+        assert 'bob' in readme
+        assert 'charlie' in readme
+        assert 'Approvers' in readme or 'approvers' in readme.lower()
+        assert 'Reviewers' in readme or 'reviewers' in readme.lower()
 
     def test_prepare_template_context(self, component_dir, sample_extracted_metadata):
         """Test template context preparation."""