stefma / androidartifacts Goto Github PK

This issue is for tracking the Milestone 2 only:

• #39
• #49
• #37
• #18
• Support only Gradle 4.6 and up(?)
• Update AGP to 3.2.0 (check that first: #55 )
• #69

See StefMa/bintray-release#26

Currently everything is developed in groovy.
I think it make sense to move it to kotlin. :)

In #67 we increased the properties and especially the complexiety of the project.
We have to update the README with a "property" section which explains each of them...

Should work.. 🙃

Currently there is a lot of "overhead" inside the build.gradle.kts which setup some tasks about publishing the docs to zeit/now:

Move all the stuff into the buildSrc/.
The best solution would be to provide a our own Gradle Plugin for that...

The plugin should be applicable however when it is applied.

Currently the plugin needs to be applied after the com.android.library plugin & the org.jetbrains.kotlin plugin.
Which is a bad behaviour.
We should change that so that the plugin can be applied as "first" plugin too...

Currently we create the kdoc only for the kotlin.android plugin.
But not for the normal jvm kotlin...

Currently we ship the plugin with the AGP plugin 3.1.4:

Check if it works when a consumer have applied the AGP in version 3.2.0.

Gradle recently announced dependencies a source dependencies.

Add a section (to the readme or maybe a new markdown file(?)) which explains how to apply it as source dependency.

The sources of this lib aren't published to bintray.

Could not find androidartifacts-sources.jar (guru.stefma.androidartifacts:androidartifacts:1.0.0).
Searched in the following locations:
    https://jcenter.bintray.com/guru/stefma/androidartifacts/androidartifacts/1.0.0/androidartifacts-1.0.0-sources.jar

It would be very helpful when I could see the source in my IDE to debug bugs

That's what I currently see:

Currently we blindly apply the dokka (or dokka-android) plugin when we detect a Kotlin module.

Instead of this we should react on the dokka plugin.

If it's applied, create the Kdoc. Otherwise don't.

Sent from my Nexus 5X using FastHub

See StefMa/bintray-release#4

Check how the java POM looks like if we have dependency with a filetree and change the Android POM accordingly.

See novoda/bintray-release#202

Add information how to apply the plugin with the Gradle Kotlin DSL.

We ship the dokka (and dokka-android) plugin as dependency together with this plugin.
This is a bad behaviour.

In this Gradle guide states that we can download the dependency later somehow...

We should do that and only download them when required...

If I publish in https://github.com/grandcentrix/ThirtyInch the new kotlin module the -source.jar isn't created.

• Find out if the Plugin Portal supports snapshots. See also this Slack thread of it.
  Otherwise try to use jitpack. See #10

• Setup CI to publish for each merge into master. Excluding any tags

Some guys reported that this lib don't work with kotlin. Try that out and fix it .

This repo work with kotlin...

The javadocs are not hundred percent correct.
It generates something like this:

instead of this:

This is a possible "issue" with external dependencies which should be added to the javadoc "options"

options {
            links = ["http://docs.oracle.com/javase/7/docs/api/", "http://reactivex.io/RxJava/2.x/javadoc/"]
}

Don't know how to fix that...

Beside of this the @android.support.annotation.NonNull annotation don't get added.
I don't know which kind of error this is but that should be fixed:
Required:

Currently:

Currently some descriptions of the tasks are wrong.
Check that and adjust if required

Since we only react on the fact that the android-plugin is applied:

We can simply add it as compileOnly (and maybe testRuntimeOnly) dependency...

I have dependencies added with compileOnly which should result in a dependency node in pom with scope = provided.
The dependency is missing at all.

The POM is not correctly.
I talked with Stephan Oehme (Gradle Core Dev) in slack about it.

The Gradle configurations should be mapped in the following way into the POM:

&

Tests:

Beside of it the tests are where I check the "POM correctly" are bad.
We should check if the POM contain everything in the same order. Otherwise they check a different version-tag in the POM

In #27 we have created three different plugins.
Now we should provide one single entrypoint plugin which should react on the applied plugins.
That mean that the plugin should detect if either of the "generation plugin" is applied and should then pick (and apply) the correct provided plugin...

The license lambda requires a min version of gradle 4.10 when using kotlin to work as documented. See SAM conversion for Kotlin functions

Action<LicenseSpec> can't be converted automatically and results in this error:

license {
        ^ Type mismatch: inferred type is () -> Unit but Action<LicenseSpec> was expected

Workaround:

    license(Action{
        name = "Apache License, Version 2.0"
		// ...
    })

The workaround is less appealing but it works. Maybe this helps someone else running into this problem.

Sometimes, I don't know exactly in which cases, the following files won't be created:

• myLibName-sources.jar (located in myLibName/build/libs/)
• myLibName-javadoc.jar (located in myLibName/build/libs/)
• pom-default.xml (located in myLibName/build/publications/release/)

To manually created it we can run the following task (same order like above):

• [release]AndroidSourcesJar
• [release]AndroidJavadocsJar
• generatePomFileFor[Release]Publication

The final (and maybe always working) gradle-wrapper command would be:

./gradlew clean build releaseAndroidSourcesJar releaseAndroidJavadocsJar generatePomFileForReleasePublication artifactoryPublish

Think how to proceed here.
Maybe add dependencies to artifactoryPublish tha it should run after the other tasks...

See https://zeit.co/blog/now-2

Currently we have this todo:

This should be solved

The cache should be available.
We could just download it...

https://docs.gradle.org/4.10.2/userguide/publishing_maven.html#publishing_maven:deferred_configuration

We should provide three different plugins:

• Android
• Java
• Kotlin

Each of them could be applied like they want.
But they require that at least the corresponding "generate" plugin is already applied. The plugins above requires at last the following plugins (in the same order):

• com.android.library
• org.gradle.java-library
• org.jetbrains.kotlin.jvm

Try to upgrade.
Don't forget the consumer/

-> https://jitpack.io/

In #67 we deprecated the license method.
In the 2.0 release we should remove it completely...

Currently we use tasks.create and getByName() for getting tasks.
We should switch to the register and named function.

This is a breaking change!
It is available in Gradle 4.9+ only!

This plugin ships two different plugins:
The guru.stefma.androidartficats and the guru.stefma.javaartifacts plugin.
The first one has to be used when we are in an android project.
The second one has to be used when we are in an java or kotlin project.
The downsides of these are, that a consumer has to pick the correct plugin. Otherwise the build will probably fail.

Provide a new plugin called guru.stefma.artifacts which just pick the correct plugin and apply it.
Make use of the pluginManager.withPlugin() {}.

Setup the project that it will be possible to release it to the Gradle Portal

See https://github.com/novoda/bintray-release/blob/8b3ac020aad5dc36c1fa8aaf6a93ae6a2d722c90/core/src/main/groovy/com/novoda/gradle/release/ReleasePlugin.groovy#L45

When I visit https://androidartifacts.now.sh/androidartifacts/guru.stefma.androidartifacts.plugin/ and press on "publications" the link does not work correctly.

This should be fixed that it redirect to the gradle doc...

Publish the kdoc for this project.
Also publish the Gradle "information" via the Gradle Site Plugin.

I think the best solution would be to deploy everything to a github page.
But this should be done automatically. I don't know how to commit/push directly to a github branch in this project.
A easier solution would be to deply the docs to now.sh via a static Dockerfile.

Currently we use classes from gradle internal. See AndroidLibrary class.
Try to get rid of that...

See also: novoda/bintray-release#112 & gradle/gradle#1842

See https://maven.apache.org/pom.html#Licenses

https://github.com/StefMa/AndroidArtifacts/blob/v1.1.1/build.gradle.kts#L49

Currently it is only part of https://github.com/StefMa/bintray-release
But it should be part of this plugin to use it everywhere

Think about a different plugin "applying".
Then we have a better separation...

See novoda/bintray-release#138

Currently the kdoc can't be displayed correctly in inteelij.
See Kotlin/dokka#215

When we have a multi module project and name the artifactId different than the Project#name the generated POM file will pick the Project#name instead of the artifactId.

// settings.gradle

include(":libA", ":libB")

// libA

artifactId = "core"

// libB

artifactId = "internal

dependencies {
  implementation(project(":libA"))

The POM of libB will use libA as artifactId instead of core