unknownjoe796 / kbuild Goto Github PK

Depends on issue #6
Add an interface that allows you to import typescript libraries from NPM

It would be nice to include things like JCenter and JitPack extremely easily. This could be done super easily like this:

import org.apache.maven.model.Model
...
Model().apply {
  repositories = listOf(Repositories.jcenter, Repositories.jitpack)
}

I'd recommend the creation of:

object Repositories {
  val jcenter: Repository = ...
  val jitpack: Repository = ...
}

This is really easy to do, but this is a first good task for somebody else to take who wants to get familiar with the project.

Don't forget to create a unit test that uses it!

It is a common requirement in build files to access authentication credentials for uploading and deploying things.

Current interface idea:

object Keychain {
  var file = File(System.getProperty("user.home"))
  operator fun get(key: String): String { ... }
  operator fun set(key: String, value: String): String { ... }
}

This accesses an encrypted file.
The first time the Keychain is accessed, the system will request the encryption password from standard input, repeating until its correct or the program is manually terminated.

Modules for Kotlin Native will take some serious thought, as they have a large number of targets. I think we should probably do an individual project object per target.

This will also have to download the current version of Kotlin Native if it is not available, ideally into the same location the Gradle plugin installs it.

I'll be creating an interface that, when implemented, adds a function to get IntelliJ project files set up.

I'll be referencing the Skate Kotlin project for creating JVM IntelliJ project files, as well as referencing the project files created by IntelliJ when using a multiplatform system. This needs to work for all JAR library types.

Some specifications:

• Should be in the package com.ivieleague.kbuild.android
• Should be called AndroidModule
• Should have functions for:
  • Handling resources, probably called prepareResources(), intended to be used before editing
  • Building
  • Creating/Signing an APK
• Should be fully compatible with HasMavenInformation

Possibilities for Implementation:

• Don't use the Android build library; use the binaries directly as specified here
• Do use the Android build library found at 'com.android.tools.build:builder:2.0.0-alpha3'.

Things you can reference:

• Kobalt Android

This one shouldn't be too hard, though it will be harder than issue #5.

You will probably need the following to work on this:

• Some experience with working around build systems
• Some experience with using JUnit
• A willingness to research or knowledge of how to run JUnit manually
• Some willingness to get familiar with the principles of KBuild, especially how it models code modules. Shouldn't take too long, you'll likely need to review most of the publicly exposed interfaces.

We need JUnit support.

My recommended path is this:

• Create a JUnitModule interface
  • It should require a HasJvmJars module as a value
  • It should require a source root for the tests with a reasonable default
  • It should have a function called test(), which runs all of the tests
  • It should have a function called test(classOrTestName: String), which runs a subset of tests
  • Those functions should throw if the test fails
  • JUnit should be set up to output reports to a folder

Goals:

• The end-user should be able to add dependencies just for testing with ease
• The module should not be used to extend the end users' main module because IntelliJ views them as separate modules. Making it a separate module will ease IntelliJ support.

It needs to be possible to deploy any object with HasMavenInformation to a Maven repository, as well as to deploy to Maven local (.m2/repository).

There are multiple possibilities for this; I imagine the best one looks something like this:

val myRemoteRepository = RemoteRepository("bintray/joseph", "https://....")
object MyProject : HasMavenInformation ... { ... }
myRemoteRepository.push(MyProject)

Any thoughts?

Create an interface called KotlinJSModule which has HasJarLibraries.

I don't know all of the details of how this should look; I leave it to whoever works on this issue.

Depends on issue #6

Should probably use something like Webpack, will need to have access to all of the dependencies

Some thoughts:

• We need the ability to declare a common code module
• We need the ability to use the common code module in platform modules
• Declaring dependencies in the common code module such that the platform modules using it can find the platform-specific version of the dependency could be quite tricky. I believe Gradle has some magical metadata system for doing that; perhaps we should also support the same?
• It would be great to make it possible to easily declare, 'Make modules for every possible platform given that the dependencies are available for them'

We need to be able to easily declare a dependency on another module.