private void processGemfile()

in doc-architect/doc-architect-core/src/main/java/com/docarchitect/core/scanner/impl/ruby/BundlerDependencyScanner.java [206:268]
49 lines of code
6 McCabe index (conditional complexity)

    private void processGemfile(Path gemfile, ScanContext context, List<Component> components,
                                List<Dependency> dependencies) throws IOException {
        String gemfileContent = readFileContent(gemfile);

        // Create component for this Ruby project
        String projectName = deriveProjectName(gemfile);
        String componentId = IdGenerator.generate(projectName);

        Component component = new Component(
            componentId,
            projectName,
            ComponentType.SERVICE,
            "Ruby project using Bundler for dependency management",
            Technologies.RUBY,
            null, // repository
            Map.of() // metadata
        );
        components.add(component);

        // Parse Gemfile for dependencies with version constraints
        Map<String, GemInfo> gemfileGems = parseGemfile(gemfileContent);

        // Try to find and parse Gemfile.lock for exact versions
        Path gemfileLock = gemfile.getParent().resolve("Gemfile.lock");
        Map<String, String> lockedVersions = new HashMap<>();

        try {
            boolean lockExists = context.findFiles(GEMFILE_LOCK_NAME).anyMatch(p -> p.equals(gemfileLock)) ||
                               context.findFiles(GEMFILE_LOCK_PATTERN).anyMatch(p -> p.equals(gemfileLock));
            if (lockExists) {
                try {
                    String lockContent = readFileContent(gemfileLock);
                    lockedVersions = parseGemfileLock(lockContent);
                    log.debug("Found Gemfile.lock with {} locked gem versions", lockedVersions.size());
                } catch (IOException e) {
                    log.warn("Failed to parse Gemfile.lock for {}: {}", gemfile, e.getMessage());
                }
            }
        } catch (Exception e) {
            log.debug("Gemfile.lock check failed for {}: {}", gemfile, e.getMessage());
        }

        // Create dependency records
        for (Map.Entry<String, GemInfo> entry : gemfileGems.entrySet()) {
            String gemName = entry.getKey();
            GemInfo gemInfo = entry.getValue();

            // Use locked version if available, otherwise use constraint from Gemfile
            String version = lockedVersions.getOrDefault(gemName, gemInfo.version);

            Dependency dependency = new Dependency(
                componentId,
                RUBYGEMS_GROUP_ID,
                gemName,
                version,
                gemInfo.scope,
                true // direct dependency
            );

            dependencies.add(dependency);
            log.debug("Found gem dependency: {} {} (scope: {})", gemName, version, gemInfo.scope);
        }
    }