commit	239768bcc86d52eafa93970258506a431e914813	[log] [tgz]
author	Dagger Team <java-team-github-bot@google.com>	Tue Jan 05 16:03:04 2021 -0800
committer	Dagger Team <dagger-dev+copybara@google.com>	Tue Jan 05 16:04:25 2021 -0800
tree	3e6ba1e107cd350d34d7714b7d0c7cbbec18496d
parent	59593065a8043223e70f13b0bd052c0ce46796ba [diff]

Use runtime classpath at root to workaround Dagger/Hilt API vs Impl issue.

This CL adds a new Hilt option called 'enableClasspathAggregation' that will configure the compile classpath of the project (for app modules and tests) to use the runtime classpath. This means that transitive dependencies will be available during compilation which in turn will allow Dagger to traverse the classes along the dependency tree and will allow for Hilt's aggregating classes to be discovered.

The classpath configuration is done by resolving the runtime configuration with an artifact view and adding it to the 'CompileOnly' config. This solution is inefficient and will cause build performance impact, but it is a starting point that can be further optimized by using a smarter transform that can extract the necessary classes required by Dagger and Hilt.

Fixes: https://github.com/google/dagger/issues/1991
RELNOTES=Use runtime classpath at root to workaround Dagger/Hilt API vs Impl issue.
PiperOrigin-RevId: 350239023

44 files changed

tree: 3e6ba1e107cd350d34d7714b7d0c7cbbec18496d

README.md

Dagger

A fast dependency injector for Java and Android.

Dagger is a compile-time framework for dependency injection. It uses no reflection or runtime bytecode generation, does all its analysis at compile-time, and generates plain Java source code.

Dagger is actively maintained by the same team that works on Guava. Snapshot releases are auto-deployed to Sonatype's central Maven repository on every clean build with the version HEAD-SNAPSHOT. The current version builds upon previous work done at Square.

Documentation

You can find the dagger documentation here which has extended usage instructions and other useful information. More detailed information can be found in the API documentation.

You can also learn more from the original proposal, this talk by Greg Kick, and on the dagger-discuss@googlegroups.com mailing list.

Installation

Bazel

First, import the Dagger repository into your WORKSPACE file using http_archive.

Note: The http_archive must point to a tagged release of Dagger, not just any commit. The version of the Dagger artifacts will match the version of the tagged release.

# Top-level WORKSPACE file

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

DAGGER_TAG = "2.28.1"
DAGGER_SHA = "9e69ab2f9a47e0f74e71fe49098bea908c528aa02fa0c5995334447b310d0cdd"
http_archive(
    name = "dagger",
    strip_prefix = "dagger-dagger-%s" % DAGGER_TAG,
    sha256 = DAGGER_SHA,
    urls = ["https://github.com/google/dagger/archive/dagger-%s.zip" % DAGGER_TAG],
)

Next you will need to setup targets that export the proper dependencies and plugins. Follow the sections below to setup the dependencies you need.

Dagger Setup

First, load the Dagger artifacts and repositories, and add them to your list of maven_install artifacts.

# Top-level WORKSPACE file

load("@dagger//:workspace_defs.bzl", "DAGGER_ARTIFACTS", "DAGGER_REPOSITORIES")

maven_install(
    artifacts = DAGGER_ARTIFACTS + [...],
    repositories = DAGGER_REPOSITORIES + [...],
)

Next, load and call dagger_rules in your top-level BUILD file:

# Top-level BUILD file

load("@dagger//:workspace_defs.bzl", "dagger_rules")

dagger_rules()

This will add the following Dagger build targets: (Note that these targets already export all of the dependencies and processors they need).

deps = [
    ":dagger",                  # For Dagger
    ":dagger-spi",              # For Dagger SPI
    ":dagger-producers",        # For Dagger Producers
]

Dagger Android Setup

First, load the Dagger Android artifacts and repositories, and add them to your list of maven_install artifacts.

# Top-level WORKSPACE file

load(
    "@dagger//:workspace_defs.bzl",
    "DAGGER_ANDROID_ARTIFACTS",
    "DAGGER_ANDROID_REPOSITORIES"
)

maven_install(
    artifacts = DAGGER_ANDROID_ARTIFACTS + [...],
    repositories = DAGGER_ANDROID_REPOSITORIES + [...],
)

Next, load and call dagger_android_rules in your top-level BUILD file:

# Top-level BUILD file

load("@dagger//:workspace_defs.bzl", "dagger_android_rules")

dagger_android_rules()

This will add the following Dagger Android build targets: (Note that these targets already export all of the dependencies and processors they need).

deps = [
    ":dagger-android",          # For Dagger Android
    ":dagger-android-support",  # For Dagger Android (Support)
]

Hilt Android Setup

First, load the Hilt Android artifacts and repositories, and add them to your list of maven_install artifacts.

# Top-level WORKSPACE file

load(
    "@dagger//:workspace_defs.bzl",
    "HILT_ANDROID_ARTIFACTS",
    "HILT_ANDROID_REPOSITORIES"
)

maven_install(
    artifacts = HILT_ANDROID_ARTIFACTS + [...],
    repositories = HILT_ANDROID_REPOSITORIES + [...],
)

Next, load and call hilt_android_rules in your top-level BUILD file:

# Top-level BUILD file

load("@dagger//:workspace_defs.bzl", "hilt_android_rules")

hilt_android_rules()

This will add the following Hilt Android build targets: (Note that these targets already export all of the dependencies and processors they need).

deps = [
    ":hilt-android",            # For Hilt Android
    ":hilt-android-testing",    # For Hilt Android Testing
]

Other build systems

You will need to include the dagger-2.x.jar in your application's runtime. In order to activate code generation and generate implementations to manage your graph you will need to include dagger-compiler-2.x.jar in your build at compile time.

Maven

In a Maven project, include the dagger artifact in the dependencies section of your pom.xml and the dagger-compiler artifact as an annotationProcessorPaths value of the maven-compiler-plugin:

<dependencies>
  <dependency>
    <groupId>com.google.dagger</groupId>
    <artifactId>dagger</artifactId>
    <version>2.x</version>
  </dependency>
</dependencies>
<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.6.1</version>
      <configuration>
        <annotationProcessorPaths>
          <path>
            <groupId>com.google.dagger</groupId>
            <artifactId>dagger-compiler</artifactId>
            <version>2.x</version>
          </path>
        </annotationProcessorPaths>
      </configuration>
    </plugin>
  </plugins>
</build>

If you are using a version of the maven-compiler-plugin lower than 3.5, add the dagger-compiler artifact with the provided scope:

<dependencies>
  <dependency>
    <groupId>com.google.dagger</groupId>
    <artifactId>dagger</artifactId>
    <version>2.x</version>
  </dependency>
  <dependency>
    <groupId>com.google.dagger</groupId>
    <artifactId>dagger-compiler</artifactId>
    <version>2.x</version>
    <scope>provided</scope>
  </dependency>
</dependencies>

If you use the beta dagger-producers extension (which supplies parallelizable execution graphs), then add this to your maven configuration:

<dependencies>
  <dependency>
    <groupId>com.google.dagger</groupId>
    <artifactId>dagger-producers</artifactId>
    <version>2.x</version>
  </dependency>
</dependencies>

Gradle

// Add Dagger dependencies
dependencies {
  api 'com.google.dagger:dagger:2.x'
  annotationProcessor 'com.google.dagger:dagger-compiler:2.x'
}

If you‘re using classes in dagger.android you’ll also want to include:

api 'com.google.dagger:dagger-android:2.x'
api 'com.google.dagger:dagger-android-support:2.x' // if you use the support libraries
annotationProcessor 'com.google.dagger:dagger-android-processor:2.x'

Notes:

Some projects will want to use implementation instead of api for better compilation performance.
- See the Gradle documentation for more information on how to select appropriately, and the Android Gradle plugin documentation for Android projects.
For Kotlin projects, use kapt in place of annotationProcessor.

If you're using the Android Databinding library, you may want to increase the number of errors that javac will print. When Dagger prints an error, databinding compilation will halt and sometimes print more than 100 errors, which is the default amount for javac. For more information, see Issue 306.

gradle.projectsEvaluated {
  tasks.withType(JavaCompile) {
    options.compilerArgs << "-Xmaxerrs" << "500" // or whatever number you want
  }
}

Resources

If you do not use maven, gradle, ivy, or other build systems that consume maven-style binary artifacts, they can be downloaded directly via the Maven Central Repository.

Developer snapshots are available from Sonatype‘s snapshot repository, and are built on a clean build of the GitHub project’s master branch.

Building Dagger

See the CONTRIBUTING.md docs.

License

Copyright 2012 The Dagger Authors

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.