assfucked new test suite ; seperated version which is very fucking experimental

pommer/experimental/__init__.py

@@ -0,0 +1,183 @@
+import os
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+def parse_pom_xml(pom_path):
+    """Parse a Maven POM file with better error handling and namespace support"""
+    try:
+        if not os.path.exists(pom_path):
+            return None
+
+        # Register namespace
+        ET.register_namespace('', "http://maven.apache.org/POM/4.0.0")
+        ns = {'mvn': "http://maven.apache.org/POM/4.0.0"}
+
+        tree = ET.parse(pom_path)
+        root = tree.getroot()
+
+        # Helper function to safely get text
+        def get_text(element, path, default="unknown"):
+            elem = element.find(path, ns)
+            return elem.text if elem is not None else default
+
+        artifact_id = get_text(root, './mvn:artifactId')
+        group_id = get_text(root, './mvn:groupId')
+        version = get_text(root, './mvn:version')
+        name = get_text(root, './mvn:name', artifact_id)
+        
+        # Get Java version with better fallback logic
+        java_version = "17"  # Default
+        java_elem = root.find('./mvn:properties/mvn:java.version', ns)
+        if java_elem is not None and java_elem.text:
+            java_version = java_elem.text.strip()
+        
+        # Packaging type
+        packaging = get_text(root, './mvn:packaging', 'jar')
+
+        # Kotlin detection
+        kotlin_version = None
+        kotlin_elem = root.find('./mvn:properties/mvn:kotlin.version', ns)
+        if kotlin_elem is not None:
+            kotlin_version = kotlin_elem.text
+
+        # Check for Kotlin plugin or dependency
+        is_kotlin = False
+        if kotlin_version:
+            is_kotlin = True
+        else:
+            # Check plugins
+            for plugin in root.findall('.//mvn:plugin', ns):
+                group = plugin.find('./mvn:groupId', ns)
+                if group is not None and group.text == 'org.jetbrains.kotlin':
+                    is_kotlin = True
+                    break
+            
+            # Check dependencies
+            if not is_kotlin:
+                for dep in root.findall('.//mvn:dependency', ns):
+                    group = dep.find('./mvn:groupId', ns)
+                    artifact = dep.find('./mvn:artifactId', ns)
+                    if (group is not None and group.text == 'org.jetbrains.kotlin' and
+                            artifact is not None and 'kotlin' in artifact.text.lower()):
+                        is_kotlin = True
+                        break
+
+        return {
+            "artifact_id": artifact_id,
+            "group_id": group_id,
+            "version": version,
+            "name": name,
+            "java_version": java_version,
+            "packaging": packaging,
+            "is_kotlin": is_kotlin,
+            "kotlin_version": kotlin_version,
+            "pom_path": str(Path(pom_path).resolve()),
+            "build_system": "maven"
+        }
+
+    except Exception as e:
+        print(f"Error parsing POM file {pom_path}: {str(e)}")
+        return None
+
+def parse_gradle_file(gradle_path):
+    """Parse Gradle build files with improved regex and error handling"""
+    try:
+        if not os.path.exists(gradle_path):
+            return None
+
+        with open(gradle_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        is_kotlin_dsl = gradle_path.endswith('.kts')
+        
+        # Extract basic info with more robust regex
+        group_match = re.search(r'group\s*[=:]\s*[\'"]([^\'"]+)[\'"]', content)
+        group_id = group_match.group(1) if group_match else "unknown"
+        
+        version_match = re.search(r'version\s*[=:]\s*[\'"]([^\'"]+)[\'"]', content)
+        version = version_match.group(1) if version_match else "unknown"
+
+        # Project name detection
+        artifact_id = "unknown"
+        project_dir = os.path.dirname(gradle_path)
+        
+        # Check settings.gradle[.kts]
+        for settings_file in ['settings.gradle', 'settings.gradle.kts']:
+            settings_path = os.path.join(project_dir, settings_file)
+            if os.path.exists(settings_path):
+                try:
+                    with open(settings_path, 'r', encoding='utf-8') as f:
+                        settings_content = f.read()
+                        name_match = re.search(r'rootProject\.name\s*[=:]\s*[\'"]([^\'"]+)[\'"]', settings_content)
+                        if name_match:
+                            artifact_id = name_match.group(1)
+                            break
+                except Exception:
+                    continue
+
+        if artifact_id == "unknown":
+            artifact_id = os.path.basename(project_dir) if project_dir else "unknown"
+
+        # Java version detection with multiple patterns
+        java_version = "17"  # Default
+        
+        # Pattern 1: JavaVersion.VERSION_XX
+        version_match = re.search(r'(?:source|target)Compatibility\s*[=:]\s*JavaVersion\.VERSION_(\d+)', content)
+        if version_match:
+            java_version = version_match.group(1)
+        else:
+            # Pattern 2: sourceCompatibility = 'XX'
+            version_match = re.search(r'(?:source|target)Compatibility\s*[=:]\s*[\'"](\d+)[\'"]', content)
+            if version_match:
+                java_version = version_match.group(1)
+            else:
+                # Pattern 3: Toolchain
+                toolchain_match = re.search(
+                    r'toolchain\s*{[^}]*languageVersion\s*[=:]\s*JavaLanguageVersion\.of\(\s*(\d+)\s*\)',
+                    content, re.DOTALL
+                )
+                if toolchain_match:
+                    java_version = toolchain_match.group(1)
+
+        # Kotlin detection
+        is_kotlin = is_kotlin_dsl
+        kotlin_version = None
+        
+        if not is_kotlin:
+            # Check for Kotlin plugin
+            kotlin_plugin_match = re.search(
+                r'(?:id|kotlin)\s*[(]?\s*[\'"](?:org\.jetbrains\.kotlin\.(?:jvm|android)|kotlin)[\'"]\s*[)]?',
+                content
+            )
+            if kotlin_plugin_match:
+                is_kotlin = True
+                
+                # Try to get version
+                version_match = re.search(
+                    r'(?:id|kotlin)\s*[(]?\s*[\'"]org\.jetbrains\.kotlin\.\w+[\'"]\s*[)]?\s*version\s*[\'"]([^\'"]+)[\'"]',
+                    content
+                )
+                if version_match:
+                    kotlin_version = version_match.group(1)
+
+        # Application plugin detection
+        is_application = bool(re.search(r'id\s*[(]?\s*[\'"]application[\'"]\s*[)]?', content))
+
+        return {
+            "artifact_id": artifact_id,
+            "group_id": group_id,
+            "version": version,
+            "name": artifact_id,  # Use artifact_id as name if not specified
+            "java_version": java_version,
+            "packaging": "application" if is_application else "jar",
+            "is_kotlin": is_kotlin,
+            "kotlin_version": kotlin_version,
+            "gradle_path": str(Path(gradle_path).resolve()),
+            "is_kotlin_dsl": is_kotlin_dsl,
+            "build_system": "gradle"
+        }
+
+    except Exception as e:
+        print(f"Error parsing Gradle file {gradle_path}: {str(e)}")
+        return None

pommer/experimental/discovery.py

@@ -0,0 +1,24 @@
+import os
+import glob
+from pathlib import Path
+
+def find_pom_files(base_dir="."):
+    """Find all pom.xml files recursively"""
+    base_path = Path(base_dir).resolve()
+    return [
+        str(p) for p in 
+        base_path.glob("**/pom.xml")
+        if not any(part.startswith('.') for part in p.parts)
+    ]
+
+def find_gradle_files(base_dir="."):
+    """Find all build.gradle[.kts] files recursively"""
+    base_path = Path(base_dir).resolve()
+    gradle_files = list(base_path.glob("**/build.gradle"))
+    kts_files = list(base_path.glob("**/build.gradle.kts"))
+    
+    # Filter out hidden directories
+    return [
+        str(p) for p in gradle_files + kts_files
+        if not any(part.startswith('.') for part in p.parts)
+    ]

pommer/experimental/generator.py

@@ -0,0 +1,137 @@
+import os
+from pathlib import Path
+
+def generate_maven_workflow(pom_infos):
+    """Generate GitHub workflow for Maven projects"""
+    if not pom_infos:
+        return None
+
+    # Get highest Java version
+    java_versions = [int(info["java_version"]) for info in pom_infos if info["java_version"].isdigit()]
+    java_version = str(max(java_versions)) if java_versions else "17"
+
+    workflow = f"""name: Maven Build
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up JDK {java_version}
+        uses: actions/setup-java@v3
+        with:
+          java-version: '{java_version}'
+          distribution: 'temurin'
+          cache: 'maven'
+"""
+
+    for info in pom_infos:
+        workflow += f"""
+      - name: Build {info['name']}
+        run: mvn -B package -f "{info['pom_path']}"
+        
+      - name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: {info['artifact_id']}
+          path: {os.path.dirname(info['pom_path'])}/target/*.jar
+"""
+
+    return workflow
+
+def generate_gradle_workflow(gradle_infos):
+    """Generate GitHub workflow for Gradle projects"""
+    if not gradle_infos:
+        return None
+
+    # Get highest Java version
+    java_versions = [int(info["java_version"]) for info in gradle_infos if info["java_version"].isdigit()]
+    java_version = str(max(java_versions)) if java_versions else "17"
+
+    workflow = f"""name: Gradle Build
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up JDK {java_version}
+        uses: actions/setup-java@v3
+        with:
+          java-version: '{java_version}'
+          distribution: 'temurin'
+          cache: 'gradle'
+          
+      - name: Make gradlew executable
+        run: chmod +x gradlew
+"""
+
+    for info in gradle_infos:
+        workflow += f"""
+      - name: Build {info['name']}
+        run: ./gradlew build
+        
+      - name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: {info['artifact_id']}
+          path: build/libs/*.jar
+"""
+
+    return workflow
+
+def generate_build_script(project_infos):
+    """Generate a universal build script"""
+    script = """#!/bin/bash
+set -e
+
+echo "Universal Build Script"
+echo "======================"
+"""
+    
+    maven_projects = [p for p in project_infos if p["build_system"] == "maven"]
+    gradle_projects = [p for p in project_infos if p["build_system"] == "gradle"]
+
+    if maven_projects:
+        script += """
+# Maven projects
+echo "Building Maven projects..."
+"""
+        for project in maven_projects:
+            script += f"""
+echo "Building {project['name']}"
+mvn -f "{project['pom_path']}" clean package
+"""
+    
+    if gradle_projects:
+        script += """
+# Gradle projects
+echo "Building Gradle projects..."
+"""
+        for project in gradle_projects:
+            script += f"""
+echo "Building {project['name']}"
+cd "{os.path.dirname(project['gradle_path'])}"
+chmod +x gradlew || true
+./gradlew build || gradle build
+cd -
+"""
+    
+    script += """
+echo "Build completed successfully!"
+"""
+    return script

pommer/experimental/main.py

@@ -0,0 +1,66 @@
+import argparse
+import json
+import os
+from pathlib import Path
+from .parser import parse_pom_xml, parse_gradle_file
+from .generator import (
+    generate_maven_workflow,
+    generate_gradle_workflow,
+    generate_build_script
+)
+from .discovery import find_pom_files, find_gradle_files
+
+def main():
+    parser = argparse.ArgumentParser(description='Generate CI workflows for Java projects')
+    parser.add_argument('--dir', default='.', help='Base directory to scan')
+    parser.add_argument('--output-json', action='store_true', help='Output project info as JSON')
+    args = parser.parse_args()
+
+    # Find and parse projects
+    projects = []
+    
+    for pom_path in find_pom_files(args.dir):
+        if project := parse_pom_xml(pom_path):
+            projects.append(project)
+    
+    for gradle_path in find_gradle_files(args.dir):
+        if project := parse_gradle_file(gradle_path):
+            projects.append(project)
+
+    if not projects:
+        print("No projects found")
+        return
+
+    # Generate workflows
+    maven_projects = [p for p in projects if p["build_system"] == "maven"]
+    gradle_projects = [p for p in projects if p["build_system"] == "gradle"]
+
+    # Create output directory
+    workflows_dir = Path(".github/workflows")
+    workflows_dir.mkdir(parents=True, exist_ok=True)
+
+    if maven_projects:
+        workflow = generate_maven_workflow(maven_projects)
+        if workflow:
+            (workflows_dir / "maven.yml").write_text(workflow)
+            print("Generated Maven workflow")
+
+    if gradle_projects:
+        workflow = generate_gradle_workflow(gradle_projects)
+        if workflow:
+            (workflows_dir / "gradle.yml").write_text(workflow)
+            print("Generated Gradle workflow")
+
+    # Generate build script
+    build_script = generate_build_script(projects)
+    Path("build.sh").write_text(build_script)
+    os.chmod("build.sh", 0o755)
+    print("Generated build.sh")
+
+    if args.output_json:
+        Path("projects.json").write_text(json.dumps(projects, indent=2))
+        print("Generated projects.json")
+
+    print(f"Found {len(projects)} projects:")
+    for p in projects:
+        print(f"- {p['name']} ({p['build_system']})")

tests.py

@@ -4,10 +4,7 @@
 
 Fix this shit!
 
-Commercial Grade Test Suite for pommer.py
+Fucking assfucked shit wont pass fucking 36 Failed and 31 Passed fuck you , fix this you downy black monkey.
-
-This comprehensive test suite covers all functionality of the pommer.py script
-with extensive edge case coverage, input validation, and error handling tests.
 
 Requirements:
 - pytest