Problem:

Sometime the gradle-plugin-jflex overwrites modifications made by plugins or tasks (applied before gradle-plugin-jflex plugin).

An example can be found in stalb/JFlex_Example:

plugins {
    id 'java'
    id "org.xbib.gradle.plugin.jflex" version "1.7.0" apply false
}
repositories {
    mavenCentral()
}
def copyJava = tasks.register("copyJava", Copy) {
	from 'src/main/custom/'
	into "${project.buildDir}/generated/sources/custom/java/testJFlex"
}
sourceSets {
    main {
        java {
        	srcDir copyJava
        }
    }
}
apply plugin: "org.xbib.gradle.plugin.jflex"

The main Java SourceDirectorySet should contains copyJava output and generateJflex output,
However when gradle-plugin-jflex plugin is applied after the main Java SourceDirectorySet configuration,
the output of copyJava disappears from the SourceDirectorySet.

In fact, since the output of the copyJava task is not in the main java SourceDirectorySet anymore, it will not be even considered as a dependency of compileJava.
So running ./gradlew compileJava will not trigger the copyJava task which output will not be compiled.

If plugins which modify the java SourceDirectorySet are applied before gradle-plugin-jflex plugin, their modifications can also be overwritten.

Expected behavior:

gradle-plugin-jflex plugin should not overwrite SourceDirectorySet additions made by plugins or tasks applied previously.

In the example, running the compileJava task should trigger both generateJflex and copyJava tasks
and all their Java outputs should be compiled by compileJava.

annoyingly when writing a lexer for an Intellij plugin it seems I have to use a version of JFlex that has been patched by JetBrains. I currently use a locally built jar for de.jflex:jflex:1.7.0-SNAPSHOT.

instead of your plugin specifying compile "de.jflex:jflex:1.6.1" in the dependencies perhaps it should use compileOnly so that the user is responsible for including a JFlex version that suites their needs.

Another option could to have a configuration option that allows the user to specify a jflex version which the plugin will then download and use.

Please enable gradle cache for this plugin.

With legacy maven jflex plugin I was able to generate the output sources to a corresponding package:

/src/generated-sources/my/package/is/in/path/Lexer.java

However with the gradle plugin, it generates the file directly in the base path:

/src/generated-sources/Lexer.java

Only configuration option is

     java {
       srcDir "$buildDir/my-generated-sources/jflex"
     }

But I guess that is not meant to set up the package root. Am I understanding something wrongly?

Hi! I've set the following in build.gradle

allprojects { buildDir = ".build" }

And yet, the outputted file is still stored in build/generated-src. How do I fix this?

https://plugins.gradle.org/plugin/org.xbib.gradle.plugin.jflex/1.2.0

• They point to the (defunct) URL: https://github.com/xbib/gradle-plugin-jflex
• If you have taken the plugin over, you should update that to point at your repo
  • Thanks for taking it over!

Although I couldn't install the plugin from the official doc, I did found your example and quick and easy solution with:

plugins {
 id 'org.xbib.gradle.plugin.jflex' version '1.1.0'
}

So, I suggest that you note that for newer versions of gradle we can use this option.

And also it would be nice if we could specify the jflex directory and jflex output directory.

Thanks man, nice plugin.

I am needing to build a variant of a lucene jflex parser, which involves passing the skeleton paramter to jflex. As such, I am unable to use your plugin, which is SO darn nice! I would suggest just allowing user specified arbitrary parameters, which would meet my need but also others.

The readme states that the default target directory for generated sources is ${project.buildDir}/generated/sources/jflex, which seems like a nice idiomatic directory. But it seems like currently this is not correct and it is being generated into build/generated/sources/main.

https://github.com/jprante/gradle-plugin-jflex/blob/master/src/main/groovy/org/xbib/gradle/plugin/JFlexPlugin.groovy#L68

Problem description

If Jflex input is defined as the output of another task, this will not be taken into account by Jflex tasks.

An example can be found in stalb/JFlex_Example2:

plugins {
    id "org.xbib.gradle.plugin.jflex" version "1.7.0"
}

repositories {
    mavenCentral()
}

def copyJflex = tasks.register("copyJflex", Copy) {
    from 'src/main/custom/'
    into "${project.buildDir}/generated/sources/custom/jflex/"
}

sourceSets {
    main {
        jflex {
            srcDir copyJflex
        }
    }
}

The main Jflex SourceDirectorySet should contains copyJflex output, however this is not the case.

In fact the generateJflex task doesn't consider copyJflex as a dependency, so running generateJflex won't trigger copyJflex task and will produce nothing.

Expected behavior

• The generateJflex task should depend on the copyJflex task.
• Running the generateJflex task should trigger the copyJflex task and its output processed by Jflex.

Hi! I'd like to switch over from using @thomaslee's gradle-jflex-plugin to yours (as discussed recently in an issue in that project). However, I'm a little hesitant to pull in a build plugin from a random personal domain :) Would it be possible to get your plugin published to the maven central repository?

in your readme the groupId for the plugin is org.xbib.gradle.plugins:

    dependencies {
        classpath 'org.xbib.gradle.plugins:gradle-plugin-jflex:1.1.0'
    }

but that doesn't tally up with your maven repository org.xbib.gradle.plugin:
http://xbib.org/repository/org/xbib/gradle/plugin/gradle-plugin-jflex/

Problem description

If you configure JFlexTask directly (not using the jflex extension) this can lead to unexpected behavior.

Example 1 (see stalb/JFlex_Example3)

When using the following configuration (build.gradle)

plugins {
    id "org.xbib.gradle.plugin.jflex" version "1.7.0"
}

repositories {
    mavenCentral()
}

tasks.named('generateJflex').configure {
   // write output into custom location .
   target = file("${project.buildDir}/generated/sources/jflexCustom/")
}

the JFlex java source file is generated into ${project.buildDir}/generated/sources/jflexCustom/ as expected
but it is not compiled by the compileJava task, which actually looks into ${project.buildDir}/generated/sources/main/.

Example 2 (see stalb/JFlex_Example4)

When using the following configuration (build.gradle)

plugins {
    id "org.xbib.gradle.plugin.jflex" version "1.7.0"
}

repositories {
    mavenCentral()
}

tasks.named('generateJflex').configure {
   // enable legacy behavior of writing directly into Java source directory
   writeIntoJavaSrc = true
}

the JFlex java source file is generated into ${project.buildDir}/generated/sources/main/ instead of src/main/java/.
So the writeIntoJavaSrc flag specified for the generateJflex task is not taken into account as I would expect it to be.

Expected behavior

Example1: the java compiler should compile the java file produced by the JFlexTask.

Example 2: the java file produced by the JFlexTask should written in the Java source directory.

When using version 1.4.0, the jflex task is not available for some reason. I do not run into this issue when using version 1.3.0 of this plugin.

Using 1.3.0

λ cat build.gradle
plugins {
 id 'org.xbib.gradle.plugin.jflex' version '1.3.0'
}

λ gradle jflex

BUILD SUCCESSFUL in 432ms
1 actionable task: 1 up-to-date

Using 1.4.0

λ cat build.gradle
plugins {
 id 'org.xbib.gradle.plugin.jflex' version '1.4.0'
}

λ gradle jflex

FAILURE: Build failed with an exception.

* What went wrong:
Task 'jflex' not found in root project 'jflex-example'.

* Try:
Run gradle tasks to get a list of available tasks. Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. Run with --scan to get full insights.

* Get more help at https://help.gradle.org

BUILD FAILED in 420ms

I tested this with several gradle versions.

With just the plugin written in gradle and no sourceSets set, I run:

gradlew clean build

Then the Java generated files are written in src/main/java/.... That means in my source code, ready to be published on my VCS!

I would expect them to be written in ${project.buildDir}/generated/sources/jflex as mentioned in the documentation.

Hi,

as the jcenter/bintray were turned off it seems the plugin cannot be currently used.

Eg.

curl -v 'https://plugins.gradle.org/m2/org/xbib/gradle/plugin/gradle-plugin-jflex/1.5.0/gradle-plugin-jflex-1.5.0.module'

< HTTP/1.1 303 See Other
< Location: https://jcenter.bintray.com/org/xbib/gradle/plugin/gradle-plugin-jflex/1.5.0/gradle-plugin-jflex-1.5.0.module

An the jcenter link is then dead.

Hi,

it seems the plugin is not very friendly with Gradle 7 – it complaints about this:

https://docs.gradle.org/7.0.2/userguide/validation_problems.html#missing_annotation

Hi,
May I ask how to use the plugin ? I am not experienced with Gradle.
If I do as you presented on the plugin page, no java class is generated.
Do I have to create a task and specify some output folder ( I had like this in ant task ) ?
I mean in ant I had something like below. But only with
apply plugin: 'org.xbib.gradle.plugin.jflex'
gradle does nothing. Do I miss something ?

<target name="JFlexLexers" description="distribution" >
    <jflex file="build/installers/flex/bash.flex" outdir="dbs-app/src/main/java/com/wisecoders/dbs/sql/editor/lexers"/>
</target>