Function bodies 4 total

class WebhookLogController
{
    public function __construct(
        private readonly ModuleTemplateFactory $moduleTemplateFactory,
        private readonly ConnectionPool $connectionPool,
        private readonly ExtensionConfiguration $extensionConfiguration,
        private readonly UriBuilder $uriBuilder,
        private readonly Registry $registry,
    ) {}

    public function listAction(ServerRequestInterface $request): ResponseInterface
    {
        $moduleTemplate = $this->moduleTemplateFactory->create($request);

        $queryBuilder = $this->connectionPool
            ->getQueryBuilderForTable('tx_wortfreundeconnector_webhook_log');

        $logs = $queryBuilder
            ->select('*')
            ->from('tx_wortfreundeconnector_webhook_log')
            ->orderBy('crdate', 'DESC')
            ->setMaxResults(100)
            ->executeQuery()
            ->fetchAllAssociative();

        $stats = [
            'total' => count($logs),
            'processed' => count(a

class WebhookMiddleware implements MiddlewareInterface, LoggerAwareInterface
{
    use LoggerAwareTrait;

    private const WEBHOOK_PATH = '/wortfreunde/webhook';

    public function __construct(
        private readonly WebhookProcessorService $webhookProcessor,
        private readonly ResponseFactoryInterface $responseFactory,
        private readonly StreamFactoryInterface $streamFactory,
        private readonly ExtensionConfiguration $extensionConfiguration,
        private readonly Registry $registry,
    ) {}

    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        $path = $request->getUri()->getPath();

        if (!str_ends_with(rtrim($path, '/'), self::WEBHOOK_PATH)) {
            return $handler->handle($request);
        }

        if ($request->getMethod() !== 'POST') {
            return $this->jsonResponse(['error' => 'Method not allowed. Use POST.'], 405);
        }

        $contentType = $reques

class MarkdownConverterService
{
    private MarkdownConverter $converter;

    public function __construct()
    {
        $config = [
            'html_input' => 'strip',
            'allow_unsafe_links' => false,
            'max_nesting_level' => 20,
        ];

        $environment = new Environment($config);
        $environment->addExtension(new CommonMarkCoreExtension());
        $environment->addExtension(new TableExtension());
        $environment->addExtension(new AutolinkExtension());
        $environment->addExtension(new StrikethroughExtension());
        $environment->addExtension(new TaskListExtension());

        $this->converter = new MarkdownConverter($environment);
    }

    /**
     * Convert Markdown string to HTML
     */
    public function convert(string $markdown): string
    {
        if (empty(trim($markdown))) {
            return '';
        }

        return (string)$this->converter->convert($markdown);
    }

    /**
     * Extract the first H1 heading 

class MarkdownConverterServiceTest extends TestCase
{
    private MarkdownConverterService $subject;

    protected function setUp(): void
    {
        parent::setUp();
        $this->subject = new MarkdownConverterService();
    }

    /**
     * @test
     */
    public function convertTransformsBasicMarkdownToHtml(): void
    {
        $markdown = "# Hello World\n\nThis is a **bold** paragraph.";
        $result = $this->subject->convert($markdown);

        self::assertStringContainsString('<h1>Hello World</h1>', $result);
        self::assertStringContainsString('<strong>bold</strong>', $result);
    }

    /**
     * @test
     */
    public function convertHandlesEmptyInput(): void
    {
        self::assertSame('', $this->subject->convert(''));
        self::assertSame('', $this->subject->convert('   '));
    }

    /**
     * @test
     */
    public function convertHandlesTableMarkdown(): void
    {
        $markdown = "| Col1 | Col2 |\n|------|------|\n| A    | B    |";