Hubwiz.com
|
Online Course
|
API Manual
Gradle User Guide API Manual
Guide(105)
Section(681)
Guide
Using Gradle Plugins
Organizing Gradle Projects
Initialization Scripts
The Feature Lifecycle
The Build Announcements Plugin
Build Environment
The PMD Plugin
Introduction to Dependency Management
Build Lifecycle
The IDEA Plugin
Inspecting Dependencies
The JDepend Plugin
The Java Library Distribution Plugin
Build Cache
Building Play applications
The CodeNarc Plugin
The Distribution Plugin
Build Script Basics
Comparing Builds
Testing in Java & JVM projects
Using Ant from Gradle
The Scala Plugin
The Ear Plugin
Composite builds
The Directories and Files Gradle Uses
The ANTLR Plugin
Building native software
The Signing Plugin
Getting Started
The Jetty Plugin
Build Init Plugin
Dependency Types
The War Plugin
License Information
Working with Dependencies
Building C++ applications and libraries
A Groovy Build Script Primer
Gradle User Manual
The Groovy Plugin
The Build Dashboard Plugin
Writing Custom Plugins
Lazy Configuration
Extending the software model
The OSGi Plugin
Task Configuration Avoidance
Managing Transitive Dependencies
Gradle User Manual: Version 5.4.1
Working With Files
Command-Line Interface
The Java Platform Plugin
Repository Types
Rule based model configuration
Upgrading your build from Gradle 4.x to 5.0
Testing Build Logic with TestKit
What is Gradle?
Installing Gradle
Authoring Multi-Project Builds
Declaring Dependencies
Dependency Management Terminology
Writing Build Scripts
Upgrading your build from Gradle 5.x
Implementing model rules in a plugin
The Base Plugin
Troubleshooting
Publishing
Attribute based matching in dependency resolution
The JaCoCo Plugin
Potential Traps
The Java Library Plugin
The Gradle Wrapper
Dependency Management for Java Projects
The FindBugs Plugin
Troubleshooting Dependency Resolution
Gradle Plugin Development Plugin
The Dependency Cache
Maven Publish Plugin
Embedding Gradle using the Tooling API
Migrating Builds From Apache Ant
Declaring Repositories
Managing Dependency Configurations
The Java Plugin
Authoring Maintainable Builds
The Application Plugin
Executing Multi-Project Builds
Migrating Builds From Apache Maven
Dependency Locking
The Eclipse Plugins
Gradle & Third-party Tools
Writing Custom Task Classes
Customizing Dependency Resolution Behavior
Gradle Plugin Reference
Software model concepts
Feature variants and optional dependencies
Authoring Tasks
Installing Gradle
Maven Plugin
Legacy publishing
The Project Report Plugin
Building Java & JVM projects
Gradle Kotlin DSL Primer
The Announce Plugin
The Checkstyle Plugin
Logging
The Gradle Daemon
Ivy Publish Plugin
Section
What plugins do - Using Gradle Plugins
Types of plugins - Using Gradle Plugins
Using plugins - Using Gradle Plugins
Script plugins - Using Gradle Plugins
Binary plugins - Using Gradle Plugins
Finding community plugins - Using Gradle Plugins
More on plugins - Using Gradle Plugins
Separate language-specific source files - Organizing Gradle Projects
Separate source files per test type - Organizing Gradle Projects
Use standard conventions as much as possible - Organizing Gradle Projects
Always define a settings file - Organizing Gradle Projects
Use buildSrc to abstract imperative logic - Organizing Gradle Projects
Declare properties in gradle.properties file - Organizing Gradle Projects
Avoid overlapping task outputs - Organizing Gradle Projects
Standardizing builds with a custom Gradle distribution - Organizing Gradle Projects
Basic usage - Initialization Scripts
Using an init script - Initialization Scripts
Writing an init script - Initialization Scripts
External dependencies for the init script - Initialization Scripts
Init script plugins - Initialization Scripts
States - The Feature Lifecycle
Backwards Compatibility Policy - The Feature Lifecycle
Usage - The Build Announcements Plugin
Gradle properties - Build Environment
System properties - Build Environment
Environment variables - Build Environment
Project properties - Build Environment
Configuring JVM memory - Build Environment
Configuring a task using project properties - Build Environment
Accessing the web through a HTTP proxy - Build Environment
Usage - The PMD Plugin
Tasks - The PMD Plugin
Dependency management - The PMD Plugin
Configuration - The PMD Plugin
What is dependency management? - Introduction to Dependency Management
Dependency management in Gradle - Introduction to Dependency Management
How dependency resolution works - Introduction to Dependency Management
Build phases - Build Lifecycle
Settings file - Build Lifecycle
Multi-project builds - Build Lifecycle
Initialization - Build Lifecycle
Configuration and execution of a single project build - Build Lifecycle
Responding to the lifecycle in the build script - Build Lifecycle
Usage - The IDEA Plugin
Tasks - The IDEA Plugin
Configuration - The IDEA Plugin
Customizing the generated files - The IDEA Plugin
Further things to consider - The IDEA Plugin
Listing dependencies in a project - Inspecting Dependencies
Identifying which dependency version was selected and why - Inspecting Dependencies
Justifying dependency declarations with custom reasons - Inspecting Dependencies
Usage - The JDepend Plugin
Tasks - The JDepend Plugin
Dependency management - The JDepend Plugin
Configuration - The JDepend Plugin
Usage - The Java Library Distribution Plugin
Tasks - The Java Library Distribution Plugin
Including other resources in the distribution - The Java Library Distribution Plugin
Overview - Build Cache
Enable the Build Cache - Build Cache
Task Output Caching - Build Cache
Cacheable tasks - Build Cache
Enable caching of non-cacheable tasks - Build Cache
Configure the Build Cache - Build Cache
How to set up an HTTP build cache backend - Build Cache
Implement your own Build Cache - Build Cache
Usage - Building Play applications
Limitations - Building Play applications
Software Model - Building Play applications
Project Layout - Building Play applications
Tasks - Building Play applications
Finding out more about your project - Building Play applications
Running a Play application - Building Play applications
Configuring a Play application - Building Play applications
Multi-project Play applications - Building Play applications
Packaging a Play application for distribution - Building Play applications
Building a Play application with an IDE - Building Play applications
Resources - Building Play applications
Usage - The CodeNarc Plugin
Tasks - The CodeNarc Plugin
Project layout - The CodeNarc Plugin
Dependency management - The CodeNarc Plugin
Configuration - The CodeNarc Plugin
Usage - The Distribution Plugin
Tasks - The Distribution Plugin
Distribution contents - The Distribution Plugin
Publishing - The Distribution Plugin
Projects and tasks - Build Script Basics
Hello world - Build Script Basics
Build scripts are code - Build Script Basics
Task dependencies - Build Script Basics
Dynamic tasks - Build Script Basics
Manipulating existing tasks - Build Script Basics
Groovy DSL shortcut notations - Build Script Basics
Extra task properties - Build Script Basics
Using Ant Tasks - Build Script Basics
Using methods - Build Script Basics
Default tasks - Build Script Basics
Configure by DAG - Build Script Basics
External dependencies for the build script - Build Script Basics
Definition of terms - Comparing Builds
Current Capabilities - Comparing Builds
Comparing Gradle Builds - Comparing Builds
The basics - Testing in Java & JVM projects
Test execution - Testing in Java & JVM projects
Test filtering - Testing in Java & JVM projects
Test reporting - Testing in Java & JVM projects
Test detection - Testing in Java & JVM projects
Test grouping - Testing in Java & JVM projects
Using JUnit 5 - Testing in Java & JVM projects
Test execution order in TestNG - Testing in Java & JVM projects
Configuring integration tests - Testing in Java & JVM projects
Skipping the tests - Testing in Java & JVM projects
Forcing tests to run - Testing in Java & JVM projects
Debugging when running tests - Testing in Java & JVM projects
Using Ant tasks and types in your build - Using Ant from Gradle
Importing an Ant build - Using Ant from Gradle
Ant properties and references - Using Ant from Gradle
Ant logging - Using Ant from Gradle
API - Using Ant from Gradle
Usage - The Scala Plugin
Tasks - The Scala Plugin
Project layout - The Scala Plugin
Dependency management - The Scala Plugin
Automatic configuration of scalaClasspath - The Scala Plugin
Configuring the Zinc compiler - The Scala Plugin
Convention properties - The Scala Plugin
Source set properties - The Scala Plugin
Compiling in external process - The Scala Plugin
Incremental compilation - The Scala Plugin
Compiling and testing for Java 6 or Java 7 - The Scala Plugin
Eclipse Integration - The Scala Plugin
IntelliJ IDEA Integration - The Scala Plugin
Usage - The Ear Plugin
Tasks - The Ear Plugin
Project layout - The Ear Plugin
Dependency management - The Ear Plugin
Convention properties - The Ear Plugin
Ear - The Ear Plugin
Customizing - The Ear Plugin
Using custom descriptor file - The Ear Plugin
What is a composite build? - Composite builds
Defining a composite build - Composite builds
Interacting with a composite build - Composite builds
Declaring the dependencies substituted by an included build - Composite builds
Depending on tasks in an included build - Composite builds
Current limitations and future plans for composite builds - Composite builds
Gradle user home directory - The Directories and Files Gradle Uses
Project root directory - The Directories and Files Gradle Uses
Usage - The ANTLR Plugin
Tasks - The ANTLR Plugin
Project layout - The ANTLR Plugin
Dependency management - The ANTLR Plugin
Convention properties - The ANTLR Plugin
Source set properties - The ANTLR Plugin
Controlling the ANTLR generator process - The ANTLR Plugin
Features - Building native software
Supported languages - Building native software
Tool chain support - Building native software
Tool chain installation - Building native software
Native software model - Building native software
Parallel Compilation - Building native software
Building a library - Building native software
Building an executable - Building native software
Assembling or building dependents - Building native software
Tasks - Building native software
Finding out more about your project - Building native software
Language support - Building native software
Configuring the compiler, assembler and linker - Building native software
Windows Resources - Building native software
Library Dependencies - Building native software
Precompiled Headers - Building native software
Native Binary Variants - Building native software
Tool chains - Building native software
Visual Studio IDE integration - Building native software
CUnit support - Building native software
GoogleTest support - Building native software
Usage - The Signing Plugin
Signatory credentials - The Signing Plugin
Using gpg-agent - The Signing Plugin
Specifying what to sign - The Signing Plugin
Publishing the signatures - The Signing Plugin
Signing POM files - The Signing Plugin
Before you start - Getting Started
Installation - Getting Started
Try Gradle - Getting Started
Command line vs IDEs - Getting Started
Executing Gradle builds - Getting Started
Authoring Gradle builds - Getting Started
Integrating 3rd-party tools with Gradle - Getting Started
Tasks - Build Init Plugin
What to set up - Build Init Plugin
Build init types - Build Init Plugin
Module dependencies - Dependency Types
File dependencies - Dependency Types
Project dependencies - Dependency Types
Gradle distribution-specific dependencies - Dependency Types
Usage - The War Plugin
Project layout - The War Plugin
Tasks - The War Plugin
Dependency management - The War Plugin
Publishing - The War Plugin
Convention properties - The War Plugin
War - The War Plugin
Customizing - The War Plugin
Gradle Documentation - License Information
Gradle Build Scan Plugin - License Information
Iterating over dependencies assigned to a configuration - Working with Dependencies
Iterating over artifacts resolved for a module - Working with Dependencies
Navigating the dependency graph - Working with Dependencies
Accessing a module��s metadata file - Working with Dependencies
Features - Building C++ applications and libraries
Plugin overview - Building C++ applications and libraries
Building an application - Building C++ applications and libraries
Building a library - Building C++ applications and libraries
C++ source layout - Building C++ applications and libraries
Declaring dependencies - Building C++ applications and libraries
Configure for different targets - Building C++ applications and libraries
IDE integration - Building C++ applications and libraries
Unit Testing support - Building C++ applications and libraries
Incremental Compilation - Building C++ applications and libraries
Parallel Compilation - Building C++ applications and libraries
Cached Compilation - Building C++ applications and libraries
Tool chain support - Building C++ applications and libraries
Limitations - Building C++ applications and libraries
Feedback and Contributing - Building C++ applications and libraries
The Project object - A Groovy Build Script Primer
Properties - A Groovy Build Script Primer
Methods - A Groovy Build Script Primer
Blocks - A Groovy Build Script Primer
Local variables - A Groovy Build Script Primer
New projects with Gradle - Gradle User Manual
Using existing Gradle builds - Gradle User Manual
Getting help - Gradle User Manual
Licenses - Gradle User Manual
Usage - The Groovy Plugin
Tasks - The Groovy Plugin
Project layout - The Groovy Plugin
Dependency management - The Groovy Plugin
Automatic configuration of groovyClasspath - The Groovy Plugin
Convention properties - The Groovy Plugin
Source set properties - The Groovy Plugin
GroovyCompile - The Groovy Plugin
Compiling and testing for Java 6 or Java 7 - The Groovy Plugin
Usage - The Build Dashboard Plugin
Tasks - The Build Dashboard Plugin
Project layout - The Build Dashboard Plugin
Dependency management - The Build Dashboard Plugin
Configuration - The Build Dashboard Plugin
Packaging a plugin - Writing Custom Plugins
Writing a simple plugin - Writing Custom Plugins
Making the plugin configurable - Writing Custom Plugins
Working with files in custom tasks and plugins - Writing Custom Plugins
Mapping extension properties to task properties - Writing Custom Plugins
A standalone project - Writing Custom Plugins
Providing a configuration DSL for the plugin - Writing Custom Plugins
Service injection - Writing Custom Plugins
Lazy properties - Lazy Configuration
Creating a Property or Provider instance - Lazy Configuration
Connecting properties together - Lazy Configuration
Working with files - Lazy Configuration
Working with task inputs and outputs - Lazy Configuration
Working with collections - Lazy Configuration
Working with maps - Lazy Configuration
Applying a convention to a property - Lazy Configuration
Making a property unmodifiable - Lazy Configuration
Guidelines - Lazy Configuration
Future development - Lazy Configuration
Provider Files API Reference - Lazy Configuration
Property Files API Reference - Lazy Configuration
Lazy Collections API Reference - Lazy Configuration
Lazy Objects API Reference - Lazy Configuration
Introduction - Extending the software model
Concepts - Extending the software model
Components - Extending the software model
Binaries - Extending the software model
Source sets - Extending the software model
Putting it all together - Extending the software model
About internal views - Extending the software model
Usage - The OSGi Plugin
Implicitly applied plugins - The OSGi Plugin
Tasks - The OSGi Plugin
Convention object - The OSGi Plugin
How does the configuration avoidance API work? - Task Configuration Avoidance
Guidelines - Task Configuration Avoidance
Migration Guide - Task Configuration Avoidance
Existing vs New API overview - Task Configuration Avoidance
Managing versions of transitive dependencies with dependency constraints - Managing Transitive Dependencies
Excluding transitive module dependencies - Managing Transitive Dependencies
Enforcing a particular dependency version - Managing Transitive Dependencies
Disabling resolution of transitive dependencies - Managing Transitive Dependencies
Importing version recommendations from a Maven BOM - Managing Transitive Dependencies
Dependency version alignment - Managing Transitive Dependencies
Component capabilities - Managing Transitive Dependencies
About Gradle - Gradle User Manual: Version 5.4.1
Getting Started - Gradle User Manual: Version 5.4.1
Upgrading and Migrating - Gradle User Manual: Version 5.4.1
Running Gradle Builds - Gradle User Manual: Version 5.4.1
Authoring Gradle Builds - Gradle User Manual: Version 5.4.1
Dependency Management - Gradle User Manual: Version 5.4.1
Publishing Artifacts - Gradle User Manual: Version 5.4.1
Java & Other JVM Projects - Gradle User Manual: Version 5.4.1
C++ Projects - Gradle User Manual: Version 5.4.1
Native Projects using the Software Model - Gradle User Manual: Version 5.4.1
Extending Gradle - Gradle User Manual: Version 5.4.1
Reference - Gradle User Manual: Version 5.4.1
Plugins - Gradle User Manual: Version 5.4.1
License Information - Gradle User Manual: Version 5.4.1
Copying a single file - Working With Files
Copying multiple files - Working With Files
Copying directory hierarchies - Working With Files
Creating archives (zip, tar, etc.) - Working With Files
Unpacking archives - Working With Files
"Creating ""uber"" or ""fat"" JARs - Working With Files"
Creating directories - Working With Files
Moving files and directories - Working With Files
Renaming files on copy - Working With Files
Deleting files and directories - Working With Files
File paths in depth - Working With Files
File copying in depth - Working With Files
Archive creation in depth - Working With Files
Executing tasks - Command-Line Interface
Common tasks - Command-Line Interface
Project reporting - Command-Line Interface
Command-line completion - Command-Line Interface
Debugging options - Command-Line Interface
Performance options - Command-Line Interface
Logging options - Command-Line Interface
Execution options - Command-Line Interface
Environment options - Command-Line Interface
Bootstrapping new projects - Command-Line Interface
Continuous Build - Command-Line Interface
Usage - The Java Platform Plugin
API and runtime separation - The Java Platform Plugin
Local project constraints - The Java Platform Plugin
Publishing platforms - The Java Platform Plugin
Consuming platforms - The Java Platform Plugin
Flat directory repository - Repository Types
Maven Central repository - Repository Types
JCenter Maven repository - Repository Types
Google Maven repository - Repository Types
Local Maven repository - Repository Types
Custom Maven repositories - Repository Types
Custom Ivy repositories - Repository Types
Supported metadata sources - Repository Types
Supported repository transport protocols - Repository Types
Background - Rule based model configuration
Basic Concepts - Rule based model configuration
Rule sources - Rule based model configuration
Advanced Concepts - Rule based model configuration
The model DSL - Rule based model configuration
The model report - Rule based model configuration
Limitations and future direction - Rule based model configuration
For all users - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.10 and earlier - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.9 and earlier - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.8 and earlier - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.7 and earlier - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.6 and earlier - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.5 and earlier - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.4 and earlier - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.3 and earlier - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.2 and earlier - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.1 and earlier - Upgrading your build from Gradle 4.x to 5.0
Upgrading from 4.0 - Upgrading your build from Gradle 4.x to 5.0
Changes in detail - Upgrading your build from Gradle 4.x to 5.0
Usage - Testing Build Logic with TestKit
Functional testing with the Gradle runner - Testing Build Logic with TestKit
Getting the plugin-under-test into the test build - Testing Build Logic with TestKit
Controlling the build environment - Testing Build Logic with TestKit
The Gradle version used to test - Testing Build Logic with TestKit
Debugging build logic - Testing Build Logic with TestKit
Testing with the Build Cache - Testing Build Logic with TestKit
Overview - What is Gradle?
Five things you need to know about Gradle - What is Gradle?
Prerequisites - Installing Gradle
Installing with a package manager - Installing Gradle
Installing manually - Installing Gradle
Verifying installation - Installing Gradle
Next steps - Installing Gradle
Cross project configuration - Authoring Multi-Project Builds
Subproject configuration - Authoring Multi-Project Builds
Execution rules for multi-project builds - Authoring Multi-Project Builds
Running tasks by their absolute path - Authoring Multi-Project Builds
Project and task paths - Authoring Multi-Project Builds
Dependencies - Which dependencies? - Authoring Multi-Project Builds
Project lib dependencies - Authoring Multi-Project Builds
Depending on the task output produced by another project - Authoring Multi-Project Builds
Parallel project execution - Authoring Multi-Project Builds
Decoupled Projects - Authoring Multi-Project Builds
Multi-Project Building and Testing - Authoring Multi-Project Builds
Multi Project and buildSrc - Authoring Multi-Project Builds
Declaring a dependency to a module - Declaring Dependencies
Declaring a file dependency - Declaring Dependencies
Declaring a project dependency - Declaring Dependencies
Resolving specific artifacts from a module dependency - Declaring Dependencies
Configuration - Dependency Management Terminology
Dependency - Dependency Management Terminology
Dependency constraint - Dependency Management Terminology
Module - Dependency Management Terminology
Module metadata - Dependency Management Terminology
Module version - Dependency Management Terminology
Platform - Dependency Management Terminology
Repository - Dependency Management Terminology
Resolution rule - Dependency Management Terminology
Transitive dependency - Dependency Management Terminology
The Gradle build language - Writing Build Scripts
The Project API - Writing Build Scripts
The script API - Writing Build Scripts
Declaring variables - Writing Build Scripts
Configuring arbitrary objects - Writing Build Scripts
Configuring arbitrary objects using an external script - Writing Build Scripts
Some Groovy basics - Writing Build Scripts
Default imports - Writing Build Scripts
Upgrading from 5.3 and earlier - Upgrading your build from Gradle 5.x
Upgrading from 5.2 and earlier - Upgrading your build from Gradle 5.x
Upgrading from 5.1 and earlier - Upgrading your build from Gradle 5.x
Upgrading from 5.0 and earlier - Upgrading your build from Gradle 5.x
Applying additional rules - Implementing model rules in a plugin
Usage - The Base Plugin
Task - The Base Plugin
Dependency management - The Base Plugin
Conventions - The Base Plugin
Troubleshooting Gradle installation - Troubleshooting
Debugging dependency resolution - Troubleshooting
Troubleshooting slow Gradle builds - Troubleshooting
Debugging build logic - Troubleshooting
Debugging IDE integration - Troubleshooting
Getting additional help - Troubleshooting
Setting up basic publishing - Publishing
Adding custom artifacts to a publication - Publishing
Publishing a custom primary artifact (no component) - Publishing
Signing artifacts - Publishing
Restricting publications to specific repositories - Publishing
Configuring publishing tasks - Publishing
Terminology - Publishing
Different kinds of configurations - Attribute based matching in dependency resolution
Configuration attributes - Attribute based matching in dependency resolution
Declaring attributes - Attribute based matching in dependency resolution
Attribute compatibility rules - Attribute based matching in dependency resolution
Attribute disambiguation rules - Attribute based matching in dependency resolution
Getting Started - The JaCoCo Plugin
Configuring the JaCoCo Plugin - The JaCoCo Plugin
JaCoCo Report configuration - The JaCoCo Plugin
Enforcing code coverage metrics - The JaCoCo Plugin
JaCoCo specific task configuration - The JaCoCo Plugin
Tasks - The JaCoCo Plugin
Dependency management - The JaCoCo Plugin
Groovy script variables - Potential Traps
Configuration and execution phase - Potential Traps
Usage - The Java Library Plugin
API and implementation separation - The Java Library Plugin
Recognizing API and implementation dependencies - The Java Library Plugin
The Java Library plugin configurations - The Java Library Plugin
Known issues - The Java Library Plugin
Adding the Gradle Wrapper - The Gradle Wrapper
Using the Gradle Wrapper - The Gradle Wrapper
Upgrading the Gradle Wrapper - The Gradle Wrapper
Customizing the Gradle Wrapper - The Gradle Wrapper
Verifying the checksum of the Gradle Wrapper JAR - The Gradle Wrapper
Dissecting a typical build script - Dependency Management for Java Projects
Declaring module dependencies - Dependency Management for Java Projects
Using dependency configurations - Dependency Management for Java Projects
Declaring common Java repositories - Dependency Management for Java Projects
Publishing artifacts - Dependency Management for Java Projects
Usage - The FindBugs Plugin
Tasks - The FindBugs Plugin
Dependency management - The FindBugs Plugin
Configuration - The FindBugs Plugin
Customizing the HTML report - The FindBugs Plugin
Resolving version conflicts - Troubleshooting Dependency Resolution
Using dynamic versions and changing modules - Troubleshooting Dependency Resolution
Controlling dependency caching programmatically - Troubleshooting Dependency Resolution
Controlling dependency caching from the command line - Troubleshooting Dependency Resolution
Locking dependency versions - Troubleshooting Dependency Resolution
Versioning of file dependencies - Troubleshooting Dependency Resolution
Constraints on configuration resolution - Troubleshooting Dependency Resolution
Usage - Gradle Plugin Development Plugin
Separate metadata cache - The Dependency Cache
Repository caches are independent - The Dependency Cache
Artifact reuse - The Dependency Cache
Checksum based storage - The Dependency Cache
Cache Locking - The Dependency Cache
Usage - Maven Publish Plugin
Tasks - Maven Publish Plugin
Publications - Maven Publish Plugin
Repositories - Maven Publish Plugin
Publishing to Maven Local - Maven Publish Plugin
Complete example - Maven Publish Plugin
Removal of deferred configuration behavior - Maven Publish Plugin
Introduction to the Tooling API - Embedding Gradle using the Tooling API
Tooling API Features - Embedding Gradle using the Tooling API
Tooling API and the Gradle Build Daemon - Embedding Gradle using the Tooling API
Quickstart - Embedding Gradle using the Tooling API
Gradle version and Java version compatibility - Embedding Gradle using the Tooling API
Java version - Embedding Gradle using the Tooling API
General guidelines - Migrating Builds From Apache Ant
Working with an imported build - Migrating Builds From Apache Ant
Managing dependencies - Migrating Builds From Apache Ant
Publishing artifacts - Migrating Builds From Apache Ant
Dealing with custom Ant tasks - Migrating Builds From Apache Ant
Working with files - Migrating Builds From Apache Ant
Migrating Ant properties - Migrating Builds From Apache Ant
Migrating multi-project builds - Migrating Builds From Apache Ant
Further reading - Migrating Builds From Apache Ant
Declaring a publicly-available repository - Declaring Repositories
Declaring a custom repository by URL - Declaring Repositories
Declaring multiple repositories - Declaring Repositories
Matching repositories to dependencies - Declaring Repositories
What is a configuration? - Managing Dependency Configurations
Defining custom configurations - Managing Dependency Configurations
Inheriting dependencies from other configurations - Managing Dependency Configurations
Usage - The Java Plugin
Tasks - The Java Plugin
Project layout - The Java Plugin
Source sets - The Java Plugin
Dependency management - The Java Plugin
Convention properties - The Java Plugin
Testing - The Java Plugin
Publishing - The Java Plugin
Incremental Java compilation - The Java Plugin
Incremental annotation processing - The Java Plugin
Compilation avoidance - The Java Plugin
Avoid using imperative logic in scripts - Authoring Maintainable Builds
Avoid using internal Gradle APIs - Authoring Maintainable Builds
Follow conventions when declaring tasks - Authoring Maintainable Builds
Improve task discoverability - Authoring Maintainable Builds
Minimize logic executed during the configuration phase - Authoring Maintainable Builds
Avoid using the GradleBuild task type - Authoring Maintainable Builds
Avoid inter-project configuration - Authoring Maintainable Builds
Avoid storing passwords in plain text - Authoring Maintainable Builds
Usage - The Application Plugin
Tasks - The Application Plugin
Application extension - The Application Plugin
Licensing - The Application Plugin
Convention properties (deprecated) - The Application Plugin
Structure of a multi-project build - Executing Multi-Project Builds
Executing a multi-project build - Executing Multi-Project Builds
Making a case for migration - Migrating Builds From Apache Maven
General guidelines - Migrating Builds From Apache Maven
Understanding the build lifecycle - Migrating Builds From Apache Maven
Performing an automatic conversion - Migrating Builds From Apache Maven
Migrating dependencies - Migrating Builds From Apache Maven
Using bills of materials (BOMs) - Migrating Builds From Apache Maven
Migrating multi-module builds (project aggregation) - Migrating Builds From Apache Maven
Migrating Maven profiles and properties - Migrating Builds From Apache Maven
Filtering resources - Migrating Builds From Apache Maven
Configuring integration tests - Migrating Builds From Apache Maven
Migrating common plugins - Migrating Builds From Apache Maven
Understanding which plugins you don��t need - Migrating Builds From Apache Maven
Dealing with uncommon and custom plugins - Migrating Builds From Apache Maven
Further reading - Migrating Builds From Apache Maven
Enabling locking on configurations - Dependency Locking
Locking buildscript classpath configuration - Dependency Locking
Generating and updating dependency locks - Dependency Locking
Lock state location and format - Dependency Locking
Running a build with lock state present - Dependency Locking
Selectively updating lock state entries - Dependency Locking
Disabling dependency locking - Dependency Locking
Locking limitations - Dependency Locking
Nebula locking plugin - Dependency Locking
Usage - The Eclipse Plugins
Tasks - The Eclipse Plugins
Configuration - The Eclipse Plugins
Customizing the generated files - The Eclipse Plugins
IDEs - Gradle & Third-party Tools
Continuous integration - Gradle & Third-party Tools
How to integrate with Gradle - Gradle & Third-party Tools
Packaging a task class - Writing Custom Task Classes
Writing a simple task class - Writing Custom Task Classes
A standalone project - Writing Custom Task Classes
Incremental tasks - Writing Custom Task Classes
Declaring and Using Command Line Options - Writing Custom Task Classes
Service injection - Writing Custom Task Classes
The Worker API - Writing Custom Task Classes
Re-using logic between task classes - Writing Custom Task Classes
Using dependency resolve rules - Customizing Dependency Resolution Behavior
Using dependency substitution rules - Customizing Dependency Resolution Behavior
Using component metadata rules - Customizing Dependency Resolution Behavior
Using component selection rules - Customizing Dependency Resolution Behavior
Using module replacement rules - Customizing Dependency Resolution Behavior
Modifying dependencies for a configuration - Customizing Dependency Resolution Behavior
Enabling Ivy dynamic resolve mode - Customizing Dependency Resolution Behavior
JVM languages and frameworks - Gradle Plugin Reference
Native languages - Gradle Plugin Reference
Packaging and distribution - Gradle Plugin Reference
Code analysis - Gradle Plugin Reference
IDE integration - Gradle Plugin Reference
Utility - Gradle Plugin Reference
Selection of feature variants and capabilities - Feature variants and optional dependencies
Declaring feature variants - Feature variants and optional dependencies
Publishing feature variants - Feature variants and optional dependencies
Dependencies on feature variants - Feature variants and optional dependencies
Handling mutually exclusive variants - Feature variants and optional dependencies
Task outcomes - Authoring Tasks
Defining tasks - Authoring Tasks
Locating tasks - Authoring Tasks
Configuring tasks - Authoring Tasks
Passing arguments to a task constructor - Authoring Tasks
Adding dependencies to a task - Authoring Tasks
Ordering tasks - Authoring Tasks
Adding a description to a task - Authoring Tasks
Replacing tasks - Authoring Tasks
Skipping tasks - Authoring Tasks
Up-to-date checks (AKA Incremental Build) - Authoring Tasks
Task rules - Authoring Tasks
Finalizer tasks - Authoring Tasks
Lifecycle tasks - Authoring Tasks
Summary - Authoring Tasks
Prerequisites - Installing Gradle
Installing with a package manager - Installing Gradle
Installing manually - Installing Gradle
Verifying installation - Installing Gradle
Next steps - Installing Gradle
Usage - Maven Plugin
Tasks - Maven Plugin
Dependency management - Maven Plugin
Convention properties - Maven Plugin
Convention methods - Maven Plugin
Interacting with Maven repositories - Maven Plugin
Introduction - Legacy publishing
Artifacts and configurations - Legacy publishing
Declaring artifacts - Legacy publishing
Publishing artifacts - Legacy publishing
More about project libraries - Legacy publishing
Usage - The Project Report Plugin
Tasks - The Project Report Plugin
Project layout - The Project Report Plugin
Dependency management - The Project Report Plugin
Convention properties - The Project Report Plugin
Introduction - Building Java & JVM projects
Declaring your source files via source sets - Building Java & JVM projects
Managing your dependencies - Building Java & JVM projects
Compiling your code - Building Java & JVM projects
Managing resources - Building Java & JVM projects
Running tests - Building Java & JVM projects
Packaging and publishing - Building Java & JVM projects
Generating API documentation - Building Java & JVM projects
Cleaning the build - Building Java & JVM projects
Building Java libraries - Building Java & JVM projects
Building Java applications - Building Java & JVM projects
Building Java web applications - Building Java & JVM projects
Building Java EE applications - Building Java & JVM projects
Building Java Platforms - Building Java & JVM projects
Prerequisites - Gradle Kotlin DSL Primer
IDE support - Gradle Kotlin DSL Primer
Kotlin DSL scripts - Gradle Kotlin DSL Primer
Type-safe model accessors - Gradle Kotlin DSL Primer
Multi-project builds - Gradle Kotlin DSL Primer
When you can��t use the plugins {} block - Gradle Kotlin DSL Primer
Working with container objects - Gradle Kotlin DSL Primer
Working with runtime properties - Gradle Kotlin DSL Primer
The Kotlin DSL Plugin - Gradle Kotlin DSL Primer
The embedded Kotlin - Gradle Kotlin DSL Primer
Interoperability - Gradle Kotlin DSL Primer
Limitations - Gradle Kotlin DSL Primer
Usage - The Announce Plugin
Configuration - The Announce Plugin
Usage - The Checkstyle Plugin
Tasks - The Checkstyle Plugin
Project layout - The Checkstyle Plugin
Dependency management - The Checkstyle Plugin
Configuration - The Checkstyle Plugin
Customizing the HTML report - The Checkstyle Plugin
Log levels - Logging
Choosing a log level - Logging
Writing your own log messages - Logging
Logging from external tools and libraries - Logging
Changing what Gradle logs - Logging
Why the Gradle Daemon is important for performance - The Gradle Daemon
Running Daemon Status - The Gradle Daemon
Disabling the Daemon - The Gradle Daemon
Stopping an existing Daemon - The Gradle Daemon
FAQ - The Gradle Daemon
Tools & IDEs - The Gradle Daemon
How does the Gradle Daemon make builds faster? - The Gradle Daemon
Usage - Ivy Publish Plugin
Tasks - Ivy Publish Plugin
Publications - Ivy Publish Plugin
Repositories - Ivy Publish Plugin
Complete example - Ivy Publish Plugin
Guide
Section
Guide(105)
Section(681)