private FallbackParsingStrategy createFallbackStrategy()

in doc-architect/doc-architect-core/src/main/java/com/docarchitect/core/scanner/impl/dotnet/KafkaScanner.java [243:336]
81 lines of code
12 McCabe index (conditional complexity)

    private FallbackParsingStrategy<MessageFlow> createFallbackStrategy() {
        return (file, content) -> {
            List<MessageFlow> flows = new ArrayList<>();

            // Check if file contains Kafka patterns
            if (!content.contains("IConsumer<") && !content.contains("IProducer<") &&
                !content.contains("ProduceAsync") && !content.contains(".Consume(")) {
                return flows;
            }

            // Extract class name from content
            java.util.regex.Pattern classPattern = java.util.regex.Pattern.compile(
                "(?:public\\s+)?class\\s+(\\w+)"
            );
            java.util.regex.Matcher classMatcher = classPattern.matcher(content);
            if (!classMatcher.find()) {
                return flows;
            }

            String className = classMatcher.group(1);
            String namespace = extractNamespace(content);
            if (namespace != null && !namespace.isEmpty()) {
                className = namespace + "." + className;
            }

            // Extract ProduceAsync calls using regex
            java.util.regex.Pattern produceAsyncPattern = java.util.regex.Pattern.compile(
                "ProduceAsync\\s*\\(\\s*\"([^\"]+)\""
            );
            java.util.regex.Matcher produceAsyncMatcher = produceAsyncPattern.matcher(content);
            while (produceAsyncMatcher.find()) {
                String topic = produceAsyncMatcher.group(1);
                flows.add(new MessageFlow(
                    className,
                    UNKNOWN_SUBSCRIBER,
                    topic,
                    DEFAULT_MESSAGE_TYPE,
                    null,
                    TECHNOLOGY
                ));
            }

            // Extract Consume calls using regex
            java.util.regex.Pattern consumePattern = java.util.regex.Pattern.compile(
                "Consume\\s*\\(\\s*\"([^\"]+)\""
            );
            java.util.regex.Matcher consumeMatcher = consumePattern.matcher(content);
            while (consumeMatcher.find()) {
                String topic = consumeMatcher.group(1);
                flows.add(new MessageFlow(
                    UNKNOWN_PUBLISHER,
                    className,
                    topic,
                    DEFAULT_MESSAGE_TYPE,
                    null,
                    TECHNOLOGY
                ));
            }

            // Extract IConsumer/IProducer fields
            java.util.regex.Pattern consumerPattern = java.util.regex.Pattern.compile(
                "(?:private|public)\\s+IConsumer<[^>]+>\\s+(\\w+)"
            );
            java.util.regex.Matcher consumerMatcher = consumerPattern.matcher(content);
            if (consumerMatcher.find()) {
                flows.add(new MessageFlow(
                    UNKNOWN_PUBLISHER,
                    className,
                    DEFAULT_TOPIC,
                    DEFAULT_MESSAGE_TYPE,
                    null,
                    TECHNOLOGY
                ));
            }

            java.util.regex.Pattern producerPattern = java.util.regex.Pattern.compile(
                "(?:private|public)\\s+IProducer<[^>]+>\\s+(\\w+)"
            );
            java.util.regex.Matcher producerMatcher = producerPattern.matcher(content);
            if (producerMatcher.find()) {
                flows.add(new MessageFlow(
                    className,
                    UNKNOWN_SUBSCRIBER,
                    DEFAULT_TOPIC,
                    DEFAULT_MESSAGE_TYPE,
                    null,
                    TECHNOLOGY
                ));
            }

            log.debug("Fallback parsing found {} message flows in {}", flows.size(), file.getFileName());
            return flows;
        };
    }