Skip to content

jeka-dev/jeka

master
Switch branches/tags
Code

Latest commit

 

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Build Status Maven Central Gitter Twitter Follow

What is Jeka ?

Jeka is a complete Java build system ala Ant, Maven or Gradle using Java as its main language instead of using XML or Groovy/Kotlin DSLs.

Build/task definitions are expressed with plain Java classes to leverage IDE power and Java ecosystem seamlessly.

Build scripts can be coded, modeled, run, debugged and reused as regular code.

Jeka offers an execution engine, a build API and a powerful plugin architecture to make your automation tasks a breeze.


Based on simple ideas

  • Run Java methods from both IDE and command line indifferently.
  • Simply use Java libraries for building Java projects programmatically.

This is an example for building a simple Java Project.
class Build extends JkBean {

    private JkProject project;
    
    Build() {
        project = JkProject.of().simpleFacade()
            .setBaseDir(".")
            .includeJavadocAndSources(true, true)  // produce javadoc and sources jars
            .configureCompileDeps(deps -> deps
                .and("com.google.guava:guava:31.0.1-jre")
                .and("com.fasterxml.jackson.core:jackson-core:2.13.0")
            )
            .configureTestDeps(deps -> deps
                .and("org.junit.jupiter:junit-jupiter-engine:5.8.2")
            )
            .setPublishedModuleId("my.org:my-module")
            .setPublishedVersion(JkGitProcess.of().getVersionFromTag());
    }

    public void cleanPack() {
        clean();
        project.pack();  // package all artifacts of the project (jar, source jar and javadoc)
    }

}

To build the project, execute ´cleanPack´ from your IDE or execute the following command line.

/home/me/myproject>./jekaw cleanPack
Example of Springboot project.
import dev.jeka.core.api.project.JkProject;
import dev.jeka.core.tool.JkBean;
import dev.jeka.core.tool.JkInjectClasspath;
import dev.jeka.plugins.springboot.SpringbootJkBean;

@JkInjectClasspath("dev.jeka:springboot-plugin")
class Build extends JkBean {

    private final SpringbootJkBean springbootBean = getBean(SpringbootJkBean.class);

    public boolean runIT = true;
    
    Build() {
        springbootBean.setSpringbootVersion("2.2.6.RELEASE");
        springbootBean.projectBean().configure(this::configure);
    }
    
    private void configure(JkProject project) {
        project.simpleFacade()
                .configureCompileDeps(deps -> deps
                        .and("org.springframework.boot:spring-boot-starter-web")
                        .and("org.projectlombok:lombok:1.18.20")
                )
                .configureRuntimeDeps(deps -> deps
                        .minus("org.projectlombok:lombok")
                )
                .configureTestDeps(deps -> deps
                        .and("org.springframework.boot:spring-boot-starter-test")
                            .withLocalExclusions("org.junit.vintage:junit-vintage-engine")
                )
                .addTestExcludeFilterSuffixedBy("IT", !runIT);
    }

    public void cleanPack() {
        clean();
        springbootBean.projectBean().pack();
    }

}

Explore Jeka possibilities from command line jekaw -h.

User friendly

Thanks to wrapper and Jeka Plugin for Intellij, you don't need to install anything on your machine. You only need a JDK 8 or higher.

Jeka is extremly lightweight, the full distribution size is around 1 MB including source code. The whole tool is contained in a single jar of aproximatly 600 KB and has zero dependency.

It's quite easy to discover what Jeka does behind the scene and troubleshot issues encountered during the build.

Current version of Jeka is no more compatible with Jeka Plugin for Intellij. Stick with Jeka version 0.9.15.RELEASE if you still want to use the IDE plugin.

This plugin will be upgraded later to use the latest Jeka version.

Get Jeka

The distribution is the file named jeka-core-x.x.x-distrib.zip.

How to use Jeka ?

Visit following pages according your expectation :

External plugins

Jeka comes with plugins out of the box. These plugins covers the most common points a Java developer need to address when building a project. This includes plugins for IDE metadata generation (IntelliJ, Eclipse), dependency management, git, , java project building, testing, PGP signing, binary repositories, Maven interaction, scaffolding, sonarQube and web archives.

Nevertheless, Jeka is extensible and other plugins exist outside the main distib among :

Community

Image

This project is supported by OW2 consortium.

You can ask question using regular using this repository issues.

You can also use direct emailing for questions and support : djeangdev@yahoo.fr

A twitter account also exist : https://twitter.com/djeang_dev

News

  • Completely reworked execution engine. JkClass and JkPlugin have been merged in the unified JkBean concept.
  • Enhanced performance with faster startup and support for Java 11 & 17.
  • Reworked command-line syntax.
  • Improved help and documentation.
  • Experimental support for Kotlin, both for writting build code and build Kotlin projects.
  • Jeka project is now organized in a mono-repo leading in a better integrated/tested components.

Roadmap/Ideas

  • Improve landing page and provide tutorials based on Intellij plugin for easy/fast starting.
  • Stabilise api from user feedbacks. API is quite workable now but may be improved.
  • Enhance existing graphical plugin for Intellij
  • Provide a plugin for Android
  • Provides a graphical plugin for better integration with Eclipse

Please visit release note and issues for roadmap.

How to build Jeka ?

This repository is organized as a mono repo. It contains The Jeka core project along plugins and samples for automation testing.

  • dev.jeka.core : Complete Jeka tool
  • plugins : Jeka plugins released along Jeka core
  • samples : Sample projects serving for examples and automation testing
  • dev.jeka.master : The master build for building all together.

Jeka builds itself. To build Jeka full distribution from sources, the simpler is to use your IDE.

Once distribution created, add the distrib folder to your PATH environment variable.

Build Jeka from IntelliJ

  • Clone this repository into IntelliJ. Project is already configured (.iml and modules.xml are stored in git).
  • Add the JEKA_CACHE_DIR variable pointing on [USER_HOME]/.jeka/cache
  • Make sure the project is configured with a JDK8 or higher.
  • Run 'FULL BUILD' in Intellij Run Configurations to perform a full build of core + plugins + complete test suite.
  • Run 'FAST BUILD' in Intellij Run Configurations to perform a fast build of the core without tests.

For debugging the project, you have to set up Intellij in order to workaround with an Intellij issue : Settings/Preferences | Build, Execution, Deployment | Debugger | Data Views | Kotlin | enable "Disable coroutine agent. See here

Build Jeka from command line

Jeka builds itself, but we need to compile the Jeka sources prior to execute it. Fot this, a small Ant script bootstraps the build process by compiling Jeka first then launch the Jeka build.

At the repository root dir, execute : ant -f .github\workflows\build.xml.

To build the project including Sonarqube and test coverage : ant -f .github\workflows\build.xml -Dsonar.host.url=... .
Cause of Sonalqube scanner, this command has to be run with a JDK >= 11.

How to edit documentation

Documentation is generated with Material for MkDocs. Documentation sources are located (here)[docs].

You must install Python and Material for MkDocs on your computer (pip install mkdocs-material) prior to execute following command lines from the repo root directory :

  • mkdocs serve : generate and serve the documentation on localhost:8000

The documentation is also supposed to be regenerated after each push/pull-request.

How to Release

Release is done automatically by Github action on PUSH on master. If the last commit message title contains a word like 'Release:XXX' (case matters ) then a tag XXX is created and the binaries will be published on Maven Central. Otherwise, the binary wll be simply pushed on OSSRH snapshot.