Gerenciamento de dependências e plugins

In any real-world project, you'll need external libraries to add functionality without writing everything from scratch. These are also called dependencies.

Build tools like Leiningen and Deps.edn help you manage these libraries, making it easy to add, update, and remove them automatically.

With Leiningen, you declare dependencies in your project.clj file. They go into the :dependencies vector, which is a list of libraries your project needs.

Each dependency is a vector itself, containing the library's group ID, artifact ID, and version, for example:

• [group-id/artifact-id "version"]

To use an external library like tick (a simple time library), you first add it to your project.clj file under the :dependencies key:

:dependencies [[org.clojure/clojure "1.11.1"]
               [tick "0.5.0-RC1"]]

Once added, you can require the library in your namespace and use its functions. Try running this example:

With deps.edn, dependencies are declared in the :deps map. This file is typically found at the root of your project.

Each entry in :deps maps a library name to a map containing its source, usually :mvn/version for Maven Central libraries:

• {library-name {:mvn/version "version"}}

To use the same tick library with deps.edn, you'd add it to your deps.edn file like this:

{:paths ["src"]
 :deps {tick/tick {:mvn/version "0.5.0-RC1"}}}

With this in place, your code (e.g., in src/my_app/core.clj) can require and use the library. Try running it:

When you add a library, it often relies on other libraries itself to function correctly. These are called transitive dependencies.

Your build tool automatically fetches these too. For example, the tick library might depend on clojure.java.time, which will also be downloaded.

This saves you from manually tracking every single required library for your project.

Sometimes, you might need to exclude a transitive dependency. This is usually done to avoid version conflicts with other libraries or to reduce your project's overall size.

In Leiningen, you can use the :exclusions key within a dependency vector. For example, if you wanted to exclude clojure.java.time from tick:

Plugins extend the functionality of your build tool itself. They can add new tasks, automate processes, or integrate with other development tools.

Common uses include code formatting, static analysis, deployment, or running specific test suites.

Plugins are distinct from regular dependencies; they operate on the project's build process, not just provide libraries for your application code.

Leiningen supports plugins defined in your project.clj under the :plugins key. Let's look at lein-ancient, which helps check for outdated dependencies.

You'd add [lein-ancient "0.6.15"] to your :plugins vector. Then, from your terminal, you can run lein ancient check to see if your libraries are up to date.

You've learned about managing dependencies and plugins in Clojure projects. Let's test your understanding.

Great job! In this lesson, we covered:

• How to add external libraries (dependencies) using both Leiningen's project.clj and Deps.edn's deps.edn.
• The concept of transitive dependencies and how they are automatically managed.
• How to exclude specific transitive dependencies in Leiningen.
• The role of plugins in extending build tool functionality, distinct from regular libraries.

Mastering dependency and plugin management is crucial for maintaining healthy, efficient Clojure projects. Keep exploring new libraries and tools!