# kmmp-generator
Kotlin Multiplatform Project Generator allows one to automate the setup of Kotlin Multiplatform Mobile (KMM) projects. Simplify the creation of KMM projects by generating project structures, managing configurations, handling dependencies, and providing customizable code templates.


## Todo REMOVE THIS BELOW AND MOVE TO RUST DOCS IN KMMP-STRUCTURE REPO

## Project Generation
```rust
mod generator;

use generator::gradle;

use generator::module::Module;

use gradle::gradle_file::{Target,TargetInfo,Gradle};

use gradle::block;
use block::dependency::{Dependencies,Dependency,DependencyType};
use block::metadata::Metadata;
use block::plugin::{Plugins,Plugin};
use block::android_manifest::AndroidManifest;

use generator::create::Create;


use generator::project::Project;

fn createModuleInstance(moduleName : &str) -> Module {
    let plugins = Plugins(vec![
        Plugin {
            isStandardLibrarySupported: true,
            name: "plugin1",
            apply: Some(false),
        },
        Plugin {
            isStandardLibrarySupported: false,
            name: "plugin2",
            apply: Some(true),
        },
    ]);
 
    let metadata = Metadata {
        module : moduleName,
        namespace: "com.deathsdoor.test",
        version: "1.0.0",
        javaVersion: "11",
        iosDeploymentTarget: "14.0",
        minSdk: 21,
        maxSdk: 30,
    };
 
    let targets = vec![
        TargetInfo {
            name: "android",
            includeTest: false,
            target : Target::Android,
            dependencies: Dependencies(vec![
                Dependency {
                    dependencyType: DependencyType::Implementation,
                    name: "example1",
                    version: Some("1.0"),
                },
                Dependency {
                    dependencyType: DependencyType::Api,
                    name: "example2",
                    version: None,
                },
            ]),
        },
    ];
 
    let gradle = Gradle {
        plugins : plugins,
        metadata : metadata,
        commonDependencies : Dependencies(vec![
            Dependency {
                dependencyType: DependencyType::Implementation,
                name: "example1",
                version: Some("1.0"),
            },
            Dependency {
                dependencyType: DependencyType::Api,
                name: "example2",
                version: None,
            },
        ]),
        targets : targets,
    };

    let manifest = AndroidManifest {
        permissions : vec![
            "READ_EXTERNAL_STORAGE",
        ],
        namespace : "com.deathsdoor.test"
    };

    Module {
        gradle : gradle,
        manifest : Some(manifest)
    }
}

fn main() {
    let modules = vec![
        createModuleInstance("android"),
        createModuleInstance("web"),
        createModuleInstance("desktop"),
    ];

    let project = Project {
        modules : modules,
        androidSdkDirectory : "SOME\\PATH",
        properites : vec!["property1", "property2"],
        dependencyRepositories: vec!["repo1", "repo2"],
        pluginRepositories: vec!["plugin_repo1", "plugin_repo2"],
        plugins : Plugins(vec![
            Plugin {
                isStandardLibrarySupported: true,
                name: "plugin1",
                apply: Some(false),
            },
            Plugin {
                isStandardLibrarySupported: false,
                name: "plugin2",
                apply: Some(true),
            },
        ])

    };

    project.create(r"C:\Users\%USERNAME%\Desktop");
}
```


## Module Generation 

### Android Only Module

```rust
mod generator;

use generator::gradle;

use generator::module::Module;

use gradle::gradle_file::{Target,TargetInfo,Gradle};

use gradle::block;
use block::dependency::{Dependencies,Dependency,DependencyType};
use block::metadata::Metadata;
use block::plugin::{Plugins,Plugin};
use block::android_manifest::AndroidManifest;

use generator::create::Create;

fn main() {
    let plugins = Plugins(vec![
        Plugin {
            isStandardLibrarySupported: true,
            name: "plugin1",
            apply: Some(false),
        },
        Plugin {
            isStandardLibrarySupported: false,
            name: "plugin2",
            apply: Some(true),
        },
    ]);
 
    let metadata = Metadata {
        module : "module",
        namespace: "com.deathsdoor.test",
        version: "1.0.0",
        javaVersion: "11",
        iosDeploymentTarget: "14.0",
        minSdk: 21,
        maxSdk: 30,
    };
 
    let targets = vec![
        TargetInfo {
            name: "android",
            includeTest: false,
            target : Target::Android,
            dependencies: Dependencies(vec![
                Dependency {
                    dependencyType: DependencyType::Implementation,
                    name: "example1",
                    version: Some("1.0"),
                },
                Dependency {
                    dependencyType: DependencyType::Api,
                    name: "example2",
                    version: None,
                },
            ]),
        },
    ];
 
    let gradle = Gradle {
        plugins : plugins,
        metadata : metadata,
        commonDependencies : Dependencies(vec![
            Dependency {
                dependencyType: DependencyType::Implementation,
                name: "example1",
                version: Some("1.0"),
            },
            Dependency {
                dependencyType: DependencyType::Api,
                name: "example2",
                version: None,
            },
        ]),
        targets : targets,
    };

    let manifest = AndroidManifest {
        permissions : vec![
            "READ_EXTERNAL_STORAGE",
        ],
        namespace : "com.deathsdoor.test"
    };

    let module = Module {
        gradle : gradle,
        manifest : Some(manifest)
    };

    module.create(r"C:\Users\Aarav Aditya Shah\Desktop"); // File will be outputed here with correct android module structure
}
```

### Multiple Target Module

```rust
mod generator;

use generator::gradle;

use generator::module::Module;

use gradle::gradle_file::{Target,TargetInfo,Gradle};

use gradle::block;
use block::dependency::{Dependencies,Dependency,DependencyType};
use block::metadata::Metadata;
use block::plugin::{Plugins,Plugin};
use block::android_manifest::AndroidManifest;

use generator::create::Create;

fn main() {
    let plugins = Plugins(vec![
        Plugin {
            isStandardLibrarySupported: true,
            name: "plugin1",
            apply: Some(false),
        },
        Plugin {
            isStandardLibrarySupported: false,
            name: "plugin2",
            apply: Some(true),
        },
    ]);
 
    let metadata = Metadata {
        module : "module",
        namespace: "com.deathsdoor.test",
        version: "1.0.0",
        javaVersion: "11",
        iosDeploymentTarget: "14.0",
        minSdk: 21,
        maxSdk: 30,
    };
 
    let targets = vec![
        TargetInfo {
            name: "android",
            includeTest: false,
            target : Target::Android,
            dependencies: Dependencies(vec![
                Dependency {
                    dependencyType: DependencyType::Implementation,
                    name: "example1",
                    version: Some("1.0"),
                },
                Dependency {
                    dependencyType: DependencyType::Api,
                    name: "example2",
                    version: None,
                },
            ]),
        },
        TargetInfo {
            name: "desktop",
            target : Target::Desktop,
            includeTest: false,
            dependencies: Dependencies(vec![
                Dependency {
                    dependencyType: DependencyType::Implementation,
                    name: "example1",
                    version: Some("1.0"),
                },
                Dependency {
                    dependencyType: DependencyType::Api,
                    name: "example2",
                    version: None,
                },
            ]),
        },
    ];
 
    let gradle = Gradle {
        plugins : plugins,
        metadata : metadata,
        commonDependencies : Dependencies(vec![
            Dependency {
                dependencyType: DependencyType::Implementation,
                name: "example1",
                version: Some("1.0"),
            },
            Dependency {
                dependencyType: DependencyType::Api,
                name: "example2",
                version: None,
            },
        ]),
        targets : targets,
    };

    let manifest = AndroidManifest {
        permissions : vec![
            "READ_EXTERNAL_STORAGE",
        ],
        namespace : "com.deathsdoor.test"
    };

    let module = Module {
        gradle : gradle,
        manifest : Some(manifest)
    };

    module.create(r"C:\Users\Aarav Aditya Shah\Desktop"); // File will be outputed here
}
```


## File Generation Usage
```rust
mod generator;
use gradle::gradle_file::Gradle;
//Create is there for each struct that can is a file itself
use generator::create::Create;

fn main() { 
    gradle.create("C:\\Users\\Output"); // File will be outputed here
}
```

## Methods Usage

### Metadata Generation

```rust
use crate::gradle::metadata

fn main() {
    let metadata = Metadata::new(
        "com.deathsdoor",
        "1.0.0",
        "1.8",
        "14.0",
        21,
        30,
    );

    println!("{}", metadata.to_string());
}
```
Output

```kotlin
object Metadata {
    const val namespace = "com.deathsdoor"
    const val version = "1.0.0"
    
    val asJavaVersionEnum = JavaVersion.values().find { it.name.endsWith(javaVersion) }
    
    const val javaVersion = "11"
    const val iosDeploymentTarget = "14.0"
    
    const val minSdk = 21
    const val minSdk = 30
}
```

### Dependencies Generation

```rust
use crate::gradle::dependency;

fn main(){
    let dependencies = Dependencies(vec![
         Dependency {
            dependencyType: DependencyType::Implementation,
            name: "example1",
            version: Some("1.0"),
        },
        Dependency {
            dependencyType: DependencyType::Api,
            name: "example2",
            version: None,
        },
        Dependency {
            dependencyType: DependencyType::Implementation,
            name: "example3",
            version: Some("2.0"),
        },
        Dependency {
            dependencyType: DependencyType::Api,
            name: "example4",
            version: None,
        },
    ]);

    println!("{}", metadata.to_string());
}
```

Output 

```kotlin
dependencies {
    implemenation("example1:1.0")
    api(project(":example2"))
    implemenation("example3:2.0")
    api(project(":example4"))
}
```

 ### Plugin Generation

 ```rust
fn main() {
    let plugins_with_apply = Plugins(vec![
        Plugin {
            name: "plugin1",
            isStandardLibrarySupported: true,
            apply: Some(true),
        },
        Plugin {
            name: "plugin2",
            isStandardLibrarySupported: false,
            apply: Some(false),
        },
    ]);

    let plugins_without_apply = Plugins(vec![
        Plugin {
            name: "plugin3",
            isStandardLibrarySupported: true,
            apply: None,
        },
        Plugin {
            name: "plugin4",
            isStandardLibrarySupported: false,
            apply: None,
        },
    ]);

    println!("Plugins with apply:\n{}", plugins_with_apply);
    println!("Plugins without apply:\n{}", plugins_without_apply);
}
 ```

 Output

 ```kotlin
//Plugins with apply:
plugin {
    kotlin("plugin1") apply true
    id("plugin2") apply false
}

//Plugins without apply:
plugin {
    kotlin("plugin3")
    id("plugin4")
}
 ```


 ### Gradle

 #### Shared 

 ```rust 
mod generator;

use generator::gradle;

use gradle::gradle_file::{Targets,Gradle};

use gradle::block;
use block::dependency::{Dependencies,Dependency,DependencyType};
use block::metadata::Metadata;
use block::plugin::{Plugins,Plugin};

fn main() {
    let plugins = Plugins(vec![
        Plugin {
            isStandardLibrarySupported: true,
            name: "plugin1",
            apply: Some(false),
        },
        Plugin {
            isStandardLibrarySupported: false,
            name: "plugin2",
            apply: Some(true),
        },
    ]);

    let metadata = Metadata {
        namespace: "com.deathsdoor",
        version: "1.0.0",
        javaVersion: "11",
        iosDeploymentTarget: "14.0",
        minSdk: 21,
        maxSdk: 30,
    };

    let targets = vec![
        Targets::Android(Dependencies(vec![
            Dependency {
                dependencyType: DependencyType::Implementation,
                name: "example1",
                version: Some("1.0"),
            },
            Dependency {
                dependencyType: DependencyType::Api,
                name: "example2",
                version: None,
            },
        ])),
        Targets::Desktop(Dependencies(vec![
            Dependency {
                dependencyType: DependencyType::Implementation,
                name: "example1",
                version: Some("1.0"),
            },
            Dependency {
                dependencyType: DependencyType::Api,
                name: "example2",
                version: None,
            },
        ])),
    ];

    let gradle = Gradle {
        plugins : plugins,
        metadata : metadata,
        commonDependencies : Dependencies(vec![
            Dependency {
                dependencyType: DependencyType::Implementation,
                name: "example1",
                version: Some("1.0"),
            },
            Dependency {
                dependencyType: DependencyType::Api,
                name: "example2",
                version: None,
            },
        ]),
        targets : targets,
    };
    println!("{}",gradle.to_string());
}
```

Output

```kotlin
plugin {
    kotlin("plugin1") apply false
    id("plugin2") apply true
}

object Metadata {
    const val namespace = "com.deathsdoor"
    const val version = "1.0.0"

    const val javaVersion = "11"
    val asJavaVersionEnum  = JavaVersion.values().find { it.name.endsWith(javaVersion) }
    const val iosDeploymentTarget = "14.0"

    const val minSDK = 21
    const val maxSDK = 30
}

kotlin {

    android {
        compilations.all {
            kotlinOptions {
                jvmTarget = Metadata.javaVersion
            }
        }
    }

    js(IR) {
        browser()
        nodejs()
        binaries.executable()
    }

    jvm("desktop") {
        compilations.all {
            kotlinOptions {
                jvmTarget = Metadata.javaVersion
            }
        }
    }

    iosX64()
    iosArm64()
    iosSimulatorArm64()
    sourceSets {
    }
}
```