templates: respect parameters

Respect collected sources for `meson init` as well as --executable. This
regressed in 9f0ac314ba0c54cc18c2499845324efc14c1849e (part of
https://github.com/mesonbuild/meson/pull/14086, it's easier to see how with
the whole PR).

Also, add subtests (distinguishing between empty directories and those with some
file(s) within). We already had some of these but they weren't marked
as such.

Test `meson init` with a broken source file in the source directory as
we should fail with that, not ignore the file.

It's easier to test with a broken file than a working one as we can assert
the build should fail, it'll pass with just the 1 example file we generate.

Closes: https://github.com/mesonbuild/meson/issues/15286

1 files changed, 37 insertions, 18 deletions

diff --git a/mesonbuild/templates/sampleimpl.py b/mesonbuild/templates/sampleimpl.py
index d033f3c14..00735c498 100644
--- a/mesonbuild/templates/sampleimpl.py
+++ b/mesonbuild/templates/sampleimpl.py
@@ -3,6 +3,7 @@
 # Copyright © 2023-2025 Intel Corporation
 
 from __future__ import annotations
+from pathlib import Path
 
 import abc
 import os
@@ -17,6 +18,7 @@ class SampleImpl(metaclass=abc.ABCMeta):
 
     def __init__(self, args: Arguments):
         self.name = args.name
+        self.executable_name = args.executable if args.executable else None
         self.version = args.version
         self.lowercase_token = re.sub(r'[^a-z0-9]', '_', self.name.lower())
         self.uppercase_token = self.lowercase_token.upper()
@@ -24,6 +26,7 @@ class SampleImpl(metaclass=abc.ABCMeta):
         self.meson_version = '1.0.0'
         self.force = args.force
         self.dependencies = args.deps.split(',') if args.deps else []
+        self.sources: list[Path] = []
 
     @abc.abstractmethod
     def create_executable(self) -> None:
@@ -66,11 +69,18 @@ class SampleImpl(metaclass=abc.ABCMeta):
     def _format_dependencies(self) -> str:
         return ''.join(f"\n  dependency('{d}')," for d in self.dependencies)
 
+    def _format_sources(self) -> str:
+        return ''.join(f"\n  '{x}'," for x in self.sources)
+
 
 class ClassImpl(SampleImpl):
 
     """For Class based languages, like Java and C#"""
 
+    def __init__(self, args: Arguments):
+        super().__init__(args)
+        self.sources = args.srcfiles if args.srcfiles else [Path(f'{self.capitalized_token}.{self.source_ext}')]
+
     def create_executable(self) -> None:
         source_name = f'{self.capitalized_token}.{self.source_ext}'
         if not os.path.exists(source_name):
@@ -80,29 +90,32 @@ class ClassImpl(SampleImpl):
         if self.force or not os.path.exists('meson.build'):
             with open('meson.build', 'w', encoding='utf-8') as f:
                 f.write(self.exe_meson_template.format(project_name=self.name,
-                                                       exe_name=self.name,
+                                                       exe_name=self.executable_name,
                                                        source_name=source_name,
                                                        version=self.version,
                                                        meson_version=self.meson_version,
-                                                       dependencies=self._format_dependencies()))
+                                                       dependencies=self._format_dependencies(),
+                                                       source_files=self._format_sources()))
 
     def create_library(self) -> None:
         lib_name = f'{self.capitalized_token}.{self.source_ext}'
         test_name = f'{self.capitalized_token}_test.{self.source_ext}'
-        kwargs = {'utoken': self.uppercase_token,
-                  'ltoken': self.lowercase_token,
-                  'class_test': f'{self.capitalized_token}_test',
-                  'class_name': self.capitalized_token,
-                  'source_file': lib_name,
-                  'test_source_file': test_name,
-                  'test_exe_name': f'{self.lowercase_token}_test',
-                  'project_name': self.name,
-                  'lib_name': self.lowercase_token,
-                  'test_name': self.lowercase_token,
-                  'version': self.version,
-                  'meson_version': self.meson_version,
-                  'dependencies': self._format_dependencies(),
-                  }
+        kwargs = {
+            'utoken': self.uppercase_token,
+            'ltoken': self.lowercase_token,
+            'class_test': f'{self.capitalized_token}_test',
+            'class_name': self.capitalized_token,
+            'source_file': lib_name,
+            'test_source_file': test_name,
+            'test_exe_name': f'{self.lowercase_token}_test',
+            'project_name': self.name,
+            'lib_name': self.lowercase_token,
+            'test_name': self.lowercase_token,
+            'version': self.version,
+            'meson_version': self.meson_version,
+            'dependencies': self._format_dependencies(),
+            'source_files': self._format_sources(),
+        }
         if not os.path.exists(lib_name):
             with open(lib_name, 'w', encoding='utf-8') as f:
                 f.write(self.lib_template.format(**kwargs))
@@ -118,6 +131,10 @@ class FileImpl(SampleImpl):
 
     """File based languages without headers"""
 
+    def __init__(self, args: Arguments):
+        super().__init__(args)
+        self.sources = args.srcfiles if args.srcfiles else [Path(f'{self.executable_name}.{self.source_ext}')]
+
     def create_executable(self) -> None:
         source_name = f'{self.lowercase_token}.{self.source_ext}'
         if not os.path.exists(source_name):
@@ -126,11 +143,12 @@ class FileImpl(SampleImpl):
         if self.force or not os.path.exists('meson.build'):
             with open('meson.build', 'w', encoding='utf-8') as f:
                 f.write(self.exe_meson_template.format(project_name=self.name,
-                                                       exe_name=self.name,
+                                                       exe_name=self.executable_name,
                                                        source_name=source_name,
                                                        version=self.version,
                                                        meson_version=self.meson_version,
-                                                       dependencies=self._format_dependencies()))
+                                                       dependencies=self._format_dependencies(),
+                                                       source_files=self._format_sources()))
 
     def lib_kwargs(self) -> T.Dict[str, str]:
         """Get Language specific keyword arguments
@@ -153,6 +171,7 @@ class FileImpl(SampleImpl):
             'version': self.version,
             'meson_version': self.meson_version,
             'dependencies': self._format_dependencies(),
+            'source_files': self._format_sources(),
         }
 
     def create_library(self) -> None: