Merged in latest version from INFO 201

nigel.stanger / gradle-lectures

Browse code Merged in latest version from INFO 201 main
1 parent 757d61f commit e9b52f8439ffbcc92113e6be7882517636fc017d Nigel Stanger authored on 6 Dec 2022

Patch

Showing 10 changed files

Ignore Space Show notes View 01_lecture/build.gradle
plugins { id "lecture" // for debugging task dependencies // https://plugins.gradle.org/plugin/org.barfuin.gradle.taskinfo // id "org.barfuin.gradle.taskinfo" version "2.0.0" } // Configure the lecture. lecture { // TYPICAL CONFIGURATION // Specify the document targets for this lecture. Defaults to // ["slides", "handout", "notes", "examples"], which are also the // only valid values. Remove any you don't need. docTargets = [ "slides", "handout", // "notes", // "examples", ] // Specify the list of images used (\includegraphics) in the lecture // documents. Defaults to []. These will become dependencies of the // lecture documents. If the images are generated, use the name of // the generated product, NOT the source file (e.g., use "foo.pdf", // not "foo.puml"). // slidesImages = [ // "image1.png", // "image2.pdf", // "image3.pdf", // ] // ADVANCED CONFIGURATION // (i.e., DON'T TOUCH unless you know what you're doing!) // Set the lecture number. This defaults to the numeric prefix of // the lecture folder (e.g., "01_whatever"), but you can override // it if needed. Use a zero-padded string. // lectureNum = "01" // Set the filename prefix for lecture documents. Defaults to "lecture". // Lecture document filenames are formatted as "prefix_whatever.foo" // e.g., "lecture_slides.tex". // docPrefix = "foo" // Set the images directory where included images are kept. Default // "images". A lot of other things derive from this! // imageDir = project.projectDir.dir("foo") // Set the PDFs directory where the numbered versions of the lecture // documents are written. Default "pdfs". // pdfDir = project.projectDir.dir("foo") // Specify the list of files used (\input) in the lecture documents. // Defaults to the three files shown below, which are REQUIRED. All // files in the list will become dependencies of the lecture documents. // slidesFiles = [ // "paper_init.tex", // "lecturedates.tex", // "doc_init.tex" // ] // Also: // examplesImages = [ ... ] list of images used in the examples document // examplesFiles = [ ... ] list of files used in the examples document // cleanFiles = [ ... ]: list of files to be removed by the "clean" targets // cleanDirs = [ ... ]: list of directories to be removed by the "clean" targets // latexFlags = [ ... ]: list of LaTeX flags } // Typical task to generate images from PlantUML. // By convention the task name is "images.whatever", but it can really be // anything you like. Gradle will find these tasks by class name if need be. // // By default this includes all files matching .pu, .puml, or .plantuml. // You can ADD files, e.g., include "foo.uml", ".pml". // You can EXCLUDE files, e.g., exclude "bar.pu", ".plantuml". // You can REPLACE the defaults, e.g., setIncludes(["foo.uml", ".pml"]). // (There is also a setExcludes() but that defaults to empty anyway.) // Note that the argument is a list value. // // Other options: // outputFormat can be one of "pdf", "png", or "svg" // add "salt = true" if there are Salt diagrams // sourceDir and outputDir default to lecture.imageDir but can be overidden def pu2pdf = tasks.register("images.plantuml2pdf", nz.stanger.lecture.GenerateImageFromPlantumlTask) { outputFormat = "pdf" description = "Generate PDF from PlantUML." // Uncomment the following line if there are any Salt diagrams. // salt = true } // Typical task to generate images from SVG. The name is again arbitrary. // By default this includes all files matching *.svg, You can include and // exclude as outlined above. // // Other options: // outputFormat can be one of "pdf" or "png" def svg2pdf = tasks.register("images.svg2pdf", nz.stanger.lecture.GenerateImageFromSvgTask) { outputFormat = "pdf" description = "Generate PDF from SVG." // If you have multiple image tasks, you have to specify their order to // avoid "implicit dependency" errors. It usually doesn't matter what // order they run in, but the order must be specified. // mustRunAfter pu2pdf } plugins { id "lecture" // for debugging task dependencies // https://plugins.gradle.org/plugin/org.barfuin.gradle.taskinfo // id "org.barfuin.gradle.taskinfo" version "2.0.0" } lecture { docTargets = [ // remove those you don't need "slides", "handout", // "notes", // "examples", ] slidesImages = [ // example: // "image1.png", // "image2.pdf", // "image3.pdf", ] generatedImages = [ // key = destination, value = source // example: // "image2.pdf": "image2.svg", // "image3.pdf": "image3.R", ]

Ignore Space Show notes View

01_lecture/build.gradle

plugins {
    id "lecture"
    // for debugging task dependencies
    // https://plugins.gradle.org/plugin/org.barfuin.gradle.taskinfo
    // id "org.barfuin.gradle.taskinfo" version "2.0.0"
}

// Configure the lecture.
lecture {
    // TYPICAL CONFIGURATION

// Specify the document targets for this lecture. Defaults to
    // ["slides", "handout", "notes", "examples"], which are also the
    // only valid values. Remove any you don't need.
    docTargets = [
        "slides",
        "handout",
        // "notes",
        // "examples",
    ]

// Specify the list of images used (\includegraphics) in the lecture
    // documents. Defaults to []. These will become dependencies of the
    // lecture documents. If the images are generated, use the name of
    // the generated product, NOT the source file (e.g., use "foo.pdf",
    // not "foo.puml").
    // slidesImages = [
    //     "image1.png",
    //     "image2.pdf",
    //     "image3.pdf",
    // ]

// ADVANCED CONFIGURATION
    // (i.e., DON'T TOUCH unless you know what you're doing!)

// Set the lecture number. This defaults to the numeric prefix of
    // the lecture folder (e.g., "01_whatever"), but you can override
    // it if needed. Use a zero-padded string.
    // lectureNum = "01"

// Set the filename prefix for lecture documents. Defaults to "lecture".
    // Lecture document filenames are formatted as "prefix_whatever.foo"
    // e.g., "lecture_slides.tex".
    // docPrefix = "foo"

// Set the images directory where included images are kept. Default
    // "images". A lot of other things derive from this!
    // imageDir = project.projectDir.dir("foo")

// Set the PDFs directory where the numbered versions of the lecture
    // documents are written. Default "pdfs".
    // pdfDir = project.projectDir.dir("foo")

// Specify the list of files used (\input) in the lecture documents.
    // Defaults to the three files shown below, which are REQUIRED. All
    // files in the list will become dependencies of the lecture documents.
    // slidesFiles = [
    //     "paper_init.tex",
    //     "lecturedates.tex",
    //     "doc_init.tex"
    // ]

// Also:
    //  examplesImages = [ ... ] list of images used in the examples document
    //  examplesFiles = [ ... ] list of files used in the examples document
    //  cleanFiles = [ ... ]: list of files to be removed by the "clean" targets
    //  cleanDirs = [ ... ]: list of directories to be removed by the "clean" targets
    //  latexFlags = [ ... ]: list of LaTeX flags
}

// Typical task to generate images from PlantUML.
// By convention the task name is "images.whatever", but it can really be
// anything you like. Gradle will find these tasks by class name if need be.
//
// By default this includes all files matching *.pu, *.puml, or *.plantuml.
// You can ADD files, e.g., include "foo.uml", "*.pml".
// You can EXCLUDE files, e.g., exclude "bar.pu", "*.plantuml".
// You can REPLACE the defaults, e.g., setIncludes(["foo.uml", "*.pml"]).
// (There is also a setExcludes() but that defaults to empty anyway.)
// Note that the argument is a list value.
//
// Other options:
//  outputFormat can be one of "pdf", "png", or "svg"
//  add "salt = true" if there are Salt diagrams
//  sourceDir and outputDir default to lecture.imageDir but can be overidden
def pu2pdf = tasks.register("images.plantuml2pdf", nz.stanger.lecture.GenerateImageFromPlantumlTask) {
    outputFormat = "pdf"
    description = "Generate PDF from PlantUML."

// Uncomment the following line if there are any Salt diagrams.
    // salt = true
}

// Typical task to generate images from SVG. The name is again arbitrary.
// By default this includes all files matching *.svg, You can include and
// exclude as outlined above.
//
// Other options:
//  outputFormat can be one of "pdf" or "png"
def svg2pdf = tasks.register("images.svg2pdf", nz.stanger.lecture.GenerateImageFromSvgTask) {
    outputFormat = "pdf"
    description = "Generate PDF from SVG."

// If you have multiple image tasks, you have to specify their order to
    // avoid "implicit dependency" errors. It usually doesn't matter what
    // order they run in, but the order must be specified.
    // mustRunAfter pu2pdf
}

Ignore Space Show notes View buildSrc/build.gradle
plugins { id "java-gradle-plugin" } repositories { mavenCentral() } dependencies { // https://mvnrepository.com/artifact/org.danilopianini/gradle-latex implementation "org.danilopianini:gradle-latex:0.2.7" // as of 2021-12-02 // https://mvnrepository.com/artifact/net.sourceforge.plantuml/plantuml implementation group: 'net.sourceforge.plantuml', name: 'plantuml', version: '1.2022.1' // https://mvnrepository.com/artifact/commons-io/commons-io implementation group: 'commons-io', name: 'commons-io', version: '2.11.0' // SVG -> other image format conversion // https://mvnrepository.com/artifact/org.apache.xmlgraphics/fop implementation group: 'org.apache.xmlgraphics', name: 'fop', version: '2.8' // https://mvnrepository.com/artifact/org.apache.xmlgraphics/batik-rasterizer implementation group: 'org.apache.xmlgraphics', name: 'batik-rasterizer', version: '1.16' // batik-codec needed for PNG and JPEG // https://mvnrepository.com/artifact/org.apache.xmlgraphics/batik-codec // implementation group: 'org.apache.xmlgraphics', name: 'batik-codec', version: '1.16' } gradlePlugin { plugins { lecture { id = "lecture" implementationClass = "nz.stanger.lecture.Lecture" } } } // compileJava { // options.compilerArgs << '-Xlint:unchecked' // } plugins { id "java-gradle-plugin" } repositories { mavenCentral() } dependencies { // https://mvnrepository.com/artifact/org.danilopianini/gradle-latex implementation "org.danilopianini:gradle-latex:0.2.7" // as of 2021-12-02 } gradlePlugin { plugins { lecture { id = "lecture" implementationClass = "nz.stanger.lecture.Lecture" } } } // compileJava { // options.compilerArgs << '-Xlint:unchecked' // }

Ignore Space Show notes View

buildSrc/build.gradle

plugins {
    id "java-gradle-plugin"
}

repositories {
    mavenCentral()
}

dependencies {
    // https://mvnrepository.com/artifact/org.danilopianini/gradle-latex
    implementation "org.danilopianini:gradle-latex:0.2.7" // as of 2021-12-02

// https://mvnrepository.com/artifact/net.sourceforge.plantuml/plantuml
    implementation group: 'net.sourceforge.plantuml', name: 'plantuml', version: '1.2022.1'

// https://mvnrepository.com/artifact/commons-io/commons-io
    implementation group: 'commons-io', name: 'commons-io', version: '2.11.0'

// SVG -> other image format conversion
    // https://mvnrepository.com/artifact/org.apache.xmlgraphics/fop
    implementation group: 'org.apache.xmlgraphics', name: 'fop', version: '2.8'
    // https://mvnrepository.com/artifact/org.apache.xmlgraphics/batik-rasterizer
    implementation group: 'org.apache.xmlgraphics', name: 'batik-rasterizer', version: '1.16'
    // batik-codec needed for PNG and JPEG
    // https://mvnrepository.com/artifact/org.apache.xmlgraphics/batik-codec
    // implementation group: 'org.apache.xmlgraphics', name: 'batik-codec', version: '1.16'
}

gradlePlugin {
    plugins {
        lecture {
            id = "lecture"
            implementationClass = "nz.stanger.lecture.Lecture"
        }
    }
}

// compileJava {
//     options.compilerArgs << '-Xlint:unchecked' 
// }

Ignore Space Show notes View buildSrc/src/main/java/nz/stanger/lecture/GenerateImageFromPlantumlTask.java 0 → 100644
package nz.stanger.lecture; import java.awt.Color; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import java.io.StringReader; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.util.Map; import java.util.Set; import net.sourceforge.plantuml.FileFormat; import net.sourceforge.plantuml.FileFormatOption; import net.sourceforge.plantuml.SourceStringReader; import org.apache.batik.anim.dom.SAXSVGDocumentFactory; import org.apache.batik.transcoder.SVGAbstractTranscoder; import org.apache.batik.transcoder.Transcoder; import org.apache.batik.transcoder.TranscoderException; import org.apache.batik.transcoder.TranscoderInput; import org.apache.batik.transcoder.TranscoderOutput; import org.apache.batik.transcoder.image.ImageTranscoder; import org.apache.batik.transcoder.image.PNGTranscoder; import org.apache.batik.util.XMLResourceDescriptor; import org.apache.commons.io.FilenameUtils; import org.apache.fop.activity.ContainerUtil; import org.apache.fop.configuration.Configuration; import org.apache.fop.configuration.ConfigurationException; import org.apache.fop.configuration.DefaultConfigurationBuilder; import org.apache.fop.svg.PDFTranscoder; import org.gradle.api.file.DirectoryProperty; import org.gradle.api.file.FileType; import org.gradle.api.provider.Property; import org.gradle.api.tasks.Internal; import org.gradle.api.tasks.TaskAction; import org.gradle.work.ChangeType; import org.gradle.work.InputChanges; import org.w3c.dom.svg.SVGDocument; import org.w3c.dom.svg.SVGElement; /** * Generate PDF, PNG, or SVG output from PlantUML source. * * See {@link https://plantuml.com/api} for details. / abstract public class GenerateImageFromPlantumlTask extends GenerateImageFromSourceTask { /* * Whether this task includes Salt diagrams (default false). This is an * explicit property rather than inferred from the setter to avoid calling * an overridable method in the constructor. / private final Property<Boolean> salt = getProject().getObjects().property(Boolean.class); /* * Files to include in this task. These are Ant-style include and exclude * patterns as per {@code PatternFilterable}. They can be modified by * further calls to {@code include} or {@code exclude}, or replaced entirely * by calling {@code setIncludes}. * * @see org.gradle.api.tasks.util.PatternFilterable / private static final Set<String> INCLUDE_FILES = Set.of(".pu", ".puml", ".plantuml"); /** * Maps image formats to corresponding Batik transcoders. / private static final Map<ImageFormat, Transcoder> TRANSCODERS = Map.of( ImageFormat.PDF, new PDFTranscoder(), ImageFormat.PNG, new PNGTranscoder() ); /* * Constructs a task to generate images from PlantUML input. / public GenerateImageFromPlantumlTask() { DirectoryProperty imageDir = getProject().getExtensions().getByType(LectureExtension.class).getImageDir(); getSource().setDir(imageDir); include(INCLUDE_FILES); getOutputDir().convention(imageDir); getOutputFormat().convention(ImageFormat.SVG); salt.convention(false); setGroup(Lecture.LECTURE_TASK_GROUP); } /* * Returns whether or not this task includes Salt diagrams. * * @return true if this task includes Salt diagrams, otherwise false / @Internal public Property<Boolean> getSalt() { return salt; } /* * Runs this task. * * @param inputChanges the inputs that have changed / @TaskAction public void runTask(InputChanges inputChanges) { /* * Workaround for relative !include directives in PlantUML source. * * Because the PlantUML source is rendered from a string variable, it * has no real reference to the file system. Directives like {@code !include * foo.pu} that assume {@code foo.pu} is in the same directory will thus * fail. * * PlantUML provides the system property {@code plantuml.include.path} * to set the include search path * ({@link https://plantuml.com/preprocessing}, "Search path"). Normally * system properties are set in {@code gradle.properties}, but that * would hard code the name of the image source directory, breaking * configurability. * * We can't set it in either the root or sub-project * {@code gradle.properties} anyway, as the path needs to be relative to * the sub-project, not the root project, and "In a multi project build, * 'systemProp.' properties set in any project except the root will be * ignored." * ({@link https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_system_properties}) * * The solution is to explicitly set {@code plantuml.include.path} at * run time to the absolute path of the sub-project's images source * directory. / System.setProperty("plantuml.include.path", getSource().getDir().getAbsolutePath()); inputChanges.getFileChanges(getSource()).forEach(change -> { if (change.getFileType() != FileType.DIRECTORY && change.getChangeType() != ChangeType.REMOVED) { String inputFilename = change.getNormalizedPath(); String outputFilename = FilenameUtils.removeExtension(inputFilename) + getOutputFormat().get().getFileSuffix(); try ( ByteArrayOutputStream svgOutputStream = new ByteArrayOutputStream();) { // Generate SVG regardless as as all other formats are transcoded // from it anyway. File outputFile = getOutputDir().file(outputFilename).get().getAsFile(); String plantUmlSource = Files.readString(change.getFile().toPath(), StandardCharsets.UTF_8); SourceStringReader reader = new SourceStringReader(plantUmlSource); reader.outputImage(svgOutputStream, new FileFormatOption(FileFormat.SVG)); String svgSource = new String(svgOutputStream.toByteArray(), StandardCharsets.UTF_8); /* * Workaround for lack of font support in Salt diagrams. * * Salt diagrams have no way (yet) to specify the font used. * It comes out as "sans-serif" in the SVG, which will * probably become something like Helvetica in the PDF, but * who knows?. It may look awful as a result. As a hacky * workaround we can just replace the "sans-serif" font * family specification in the generated SVG before doing * anything else. * * Maybe there's a way to tell FOP to do this for us? / if (salt.get()) { // I'd like to use Roboto here, but it somehow loses the bold face :(. svgSource = svgSource.replaceAll("font-family=\"sans-serif\"", "font-family=\"Open Sans, Helvetica, Verdana, Arial, sans-serif\""); } // If we're just doing SVG, we can stop here. if (getOutputFormat().get() == ImageFormat.SVG) { Files.writeString(outputFile.toPath(), svgSource, StandardCharsets.UTF_8); return; } // https://xmlgraphics.apache.org/batik/using/dom-api.html String parser = XMLResourceDescriptor.getXMLParserClassName(); SAXSVGDocumentFactory factory = new SAXSVGDocumentFactory(parser); // https://www.programcreek.com/java-api-examples/?api=org.apache.batik.dom.svg.SAXSVGDocumentFactory SVGDocument svgDocument = factory.createSVGDocument(null, new StringReader(svgSource)); // https://thinktibits.blogspot.com/2012/12/batik-convert-svg-to-pdf-java-example.html // Step 1: read input SVG document into TranscoderInput. TranscoderInput inputSvgImage = new TranscoderInput(svgDocument); // Step 2: define OutputStream to target image and attach to TranscoderOutput ByteArrayOutputStream imageOutputStream = new ByteArrayOutputStream(); TranscoderOutput imageOutput = new TranscoderOutput(imageOutputStream); // Step 3: create appropriate image Transcoder. Transcoder transcoder = TRANSCODERS.get(getOutputFormat().get()); switch (getOutputFormat().get()) { case PNG -> { // The raster images that PlantUML generates look like shit // because they're only 72 DPI, and PlantUML provides no way // to specify higher DPI. The solution is to rasterise the // SVG at higher DPI and scale the width and height accordingly. SVGElement svgRoot = svgDocument.getRootElement(); // The width and height attributes may have units, // most likely "px". Just strip out anything that's // not a number Float scaledWidth = Float.valueOf(svgRoot.getAttribute("width").replaceAll("[^\\d]+", "")) SCALE_BY_RESOLUTION; Float scaledHeight = Float.valueOf(svgRoot.getAttribute("height").replaceAll("[^\\d]+", "")) * SCALE_BY_RESOLUTION; transcoder.addTranscodingHint(ImageTranscoder.KEY_BACKGROUND_COLOR, Color.WHITE); transcoder.addTranscodingHint(ImageTranscoder.KEY_WIDTH, scaledWidth); transcoder.addTranscodingHint(ImageTranscoder.KEY_HEIGHT, scaledHeight); transcoder.addTranscodingHint(ImageTranscoder.KEY_PIXEL_UNIT_TO_MILLIMETER, PIXEL_UNIT_TO_MM); } case PDF -> { // This seems to be necessary to ensure properly // embedded fonts when generating PDFs. transcoder.addTranscodingHint(SVGAbstractTranscoder.KEY_DEFAULT_FONT_FAMILY, "Open Sans, Helvetica, Verdana, Arial, sans serif"); // See https://stackoverflow.com/q/47884893 and https://stackoverflow.com/a/72807651 DefaultConfigurationBuilder configBuilder = new DefaultConfigurationBuilder(); // See https://stackoverflow.com/a/20389418 Configuration config = configBuilder.build(getClass().getResourceAsStream("/" + FOP_CONFIG_FILENAME)); ContainerUtil.configure((PDFTranscoder) transcoder, config); } default -> throw new TranscoderException("invalid output format: " + getOutputFormat().get().toString()); } // Step 4: write output to target format transcoder.transcode(inputSvgImage, imageOutput); // Step 5: close and flush output stream imageOutputStream.flush(); imageOutputStream.close(); try ( OutputStream fileOutputStream = new FileOutputStream(outputFile);) { imageOutputStream.writeTo(fileOutputStream); } } catch (IOException \| TranscoderException \| ConfigurationException e) { System.out.println("failed to generate " + outputFilename); // e.printStackTrace(); } } }); } }

Ignore Space Show notes View

buildSrc/src/main/java/nz/stanger/lecture/GenerateImageFromPlantumlTask.java 0 → 100644

package nz.stanger.lecture;

import java.awt.Color;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.Map;
import java.util.Set;
import net.sourceforge.plantuml.FileFormat;
import net.sourceforge.plantuml.FileFormatOption;
import net.sourceforge.plantuml.SourceStringReader;
import org.apache.batik.anim.dom.SAXSVGDocumentFactory;
import org.apache.batik.transcoder.SVGAbstractTranscoder;
import org.apache.batik.transcoder.Transcoder;
import org.apache.batik.transcoder.TranscoderException;
import org.apache.batik.transcoder.TranscoderInput;
import org.apache.batik.transcoder.TranscoderOutput;
import org.apache.batik.transcoder.image.ImageTranscoder;
import org.apache.batik.transcoder.image.PNGTranscoder;
import org.apache.batik.util.XMLResourceDescriptor;
import org.apache.commons.io.FilenameUtils;
import org.apache.fop.activity.ContainerUtil;
import org.apache.fop.configuration.Configuration;
import org.apache.fop.configuration.ConfigurationException;
import org.apache.fop.configuration.DefaultConfigurationBuilder;
import org.apache.fop.svg.PDFTranscoder;
import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.file.FileType;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.TaskAction;
import org.gradle.work.ChangeType;
import org.gradle.work.InputChanges;
import org.w3c.dom.svg.SVGDocument;
import org.w3c.dom.svg.SVGElement;

/**
 * Generate PDF, PNG, or SVG output from PlantUML source.
 *
 * See {@link https://plantuml.com/api} for details.
 */
abstract public class GenerateImageFromPlantumlTask extends GenerateImageFromSourceTask {

/**
     * Whether this task includes Salt diagrams (default false). This is an
     * explicit property rather than inferred from the setter to avoid calling
     * an overridable method in the constructor.
     */
    private final Property<Boolean> salt = getProject().getObjects().property(Boolean.class);

/**
     * Files to include in this task. These are Ant-style include and exclude
     * patterns as per {@code PatternFilterable}. They can be modified by
     * further calls to {@code include} or {@code exclude}, or replaced entirely
     * by calling {@code setIncludes}.
     *
     * @see org.gradle.api.tasks.util.PatternFilterable
     */
    private static final Set<String> INCLUDE_FILES = Set.of("*.pu", "*.puml", "*.plantuml");

/**
     * Maps image formats to corresponding Batik transcoders.
     */
    private static final Map<ImageFormat, Transcoder> TRANSCODERS = Map.of(
            ImageFormat.PDF, new PDFTranscoder(),
            ImageFormat.PNG, new PNGTranscoder()
    );

/**
     * Constructs a task to generate images from PlantUML input.
     */
    public GenerateImageFromPlantumlTask() {
        DirectoryProperty imageDir = getProject().getExtensions().getByType(LectureExtension.class).getImageDir();
        getSource().setDir(imageDir);
        include(INCLUDE_FILES);
        getOutputDir().convention(imageDir);
        getOutputFormat().convention(ImageFormat.SVG);
        salt.convention(false);
        setGroup(Lecture.LECTURE_TASK_GROUP);
    }

/**
     * Returns whether or not this task includes Salt diagrams.
     *
     * @return true if this task includes Salt diagrams, otherwise false
     */
    @Internal
    public Property<Boolean> getSalt() {
        return salt;
    }

/**
     * Runs this task.
     *
     * @param inputChanges the inputs that have changed
     */
    @TaskAction
    public void runTask(InputChanges inputChanges) {
        /**
         * Workaround for relative !include directives in PlantUML source.
         *
         * Because the PlantUML source is rendered from a string variable, it
         * has no real reference to the file system. Directives like {@code !include
         * foo.pu} that assume {@code foo.pu} is in the same directory will thus
         * fail.
         *
         * PlantUML provides the system property {@code plantuml.include.path}
         * to set the include search path
         * ({@link https://plantuml.com/preprocessing}, "Search path"). Normally
         * system properties are set in {@code gradle.properties}, but that
         * would hard code the name of the image source directory, breaking
         * configurability.
         *
         * We can't set it in either the root or sub-project
         * {@code gradle.properties} anyway, as the path needs to be relative to
         * the sub-project, not the root project, and "In a multi project build,
         * 'systemProp.' properties set in any project except the root will be
         * ignored."
         * ({@link https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_system_properties})
         *
         * The solution is to explicitly set {@code plantuml.include.path} at
         * run time to the absolute path of the sub-project's images source
         * directory.
         */
        System.setProperty("plantuml.include.path", getSource().getDir().getAbsolutePath());

inputChanges.getFileChanges(getSource()).forEach(change -> {
            if (change.getFileType() != FileType.DIRECTORY && change.getChangeType() != ChangeType.REMOVED) {
                String inputFilename = change.getNormalizedPath();
                String outputFilename = FilenameUtils.removeExtension(inputFilename) + getOutputFormat().get().getFileSuffix();

try ( ByteArrayOutputStream svgOutputStream = new ByteArrayOutputStream();) {
                    // Generate SVG regardless as as all other formats are transcoded
                    // from it anyway.
                    File outputFile = getOutputDir().file(outputFilename).get().getAsFile();

String plantUmlSource = Files.readString(change.getFile().toPath(), StandardCharsets.UTF_8);

SourceStringReader reader = new SourceStringReader(plantUmlSource);
                    reader.outputImage(svgOutputStream, new FileFormatOption(FileFormat.SVG));
                    String svgSource = new String(svgOutputStream.toByteArray(), StandardCharsets.UTF_8);

/**
                     * Workaround for lack of font support in Salt diagrams.
                     *
                     * Salt diagrams have no way (yet) to specify the font used.
                     * It comes out as "sans-serif" in the SVG, which will
                     * probably become something like Helvetica in the PDF, but
                     * who knows?. It may look awful as a result. As a hacky
                     * workaround we can just replace the "sans-serif" font
                     * family specification in the generated SVG before doing
                     * anything else.
                     *
                     * Maybe there's a way to tell FOP to do this for us?
                     */
                    if (salt.get()) {
                        // I'd like to use Roboto here, but it somehow loses the bold face :(.
                        svgSource = svgSource.replaceAll("font-family=\"sans-serif\"", "font-family=\"Open Sans, Helvetica, Verdana, Arial, sans-serif\"");
                    }

// If we're just doing SVG, we can stop here.
                    if (getOutputFormat().get() == ImageFormat.SVG) {
                        Files.writeString(outputFile.toPath(), svgSource, StandardCharsets.UTF_8);
                        return;
                    }

// https://xmlgraphics.apache.org/batik/using/dom-api.html
                    String parser = XMLResourceDescriptor.getXMLParserClassName();
                    SAXSVGDocumentFactory factory = new SAXSVGDocumentFactory(parser);

// https://www.programcreek.com/java-api-examples/?api=org.apache.batik.dom.svg.SAXSVGDocumentFactory
                    SVGDocument svgDocument = factory.createSVGDocument(null, new StringReader(svgSource));

// https://thinktibits.blogspot.com/2012/12/batik-convert-svg-to-pdf-java-example.html
                    // Step 1: read input SVG document into TranscoderInput.
                    TranscoderInput inputSvgImage = new TranscoderInput(svgDocument);

// Step 2: define OutputStream to target image and attach to TranscoderOutput
                    ByteArrayOutputStream imageOutputStream = new ByteArrayOutputStream();
                    TranscoderOutput imageOutput = new TranscoderOutput(imageOutputStream);

// Step 3: create appropriate image Transcoder.
                    Transcoder transcoder = TRANSCODERS.get(getOutputFormat().get());

// The width and height attributes may have units,
                            // most likely "px". Just strip out anything that's
                            // not a number
                            Float scaledWidth = Float.valueOf(svgRoot.getAttribute("width").replaceAll("[^\\d]+", "")) * SCALE_BY_RESOLUTION;
                            Float scaledHeight = Float.valueOf(svgRoot.getAttribute("height").replaceAll("[^\\d]+", "")) * SCALE_BY_RESOLUTION;

transcoder.addTranscodingHint(ImageTranscoder.KEY_BACKGROUND_COLOR, Color.WHITE);
                            transcoder.addTranscodingHint(ImageTranscoder.KEY_WIDTH, scaledWidth);
                            transcoder.addTranscodingHint(ImageTranscoder.KEY_HEIGHT, scaledHeight);
                            transcoder.addTranscodingHint(ImageTranscoder.KEY_PIXEL_UNIT_TO_MILLIMETER, PIXEL_UNIT_TO_MM);
                        }
                        case PDF -> {
                            // This seems to be necessary to ensure properly
                            // embedded fonts when generating PDFs.
                            transcoder.addTranscodingHint(SVGAbstractTranscoder.KEY_DEFAULT_FONT_FAMILY, "Open Sans, Helvetica, Verdana, Arial, sans serif");

// See https://stackoverflow.com/q/47884893 and https://stackoverflow.com/a/72807651
                            DefaultConfigurationBuilder configBuilder = new DefaultConfigurationBuilder();
                            // See https://stackoverflow.com/a/20389418
                            Configuration config = configBuilder.build(getClass().getResourceAsStream("/" + FOP_CONFIG_FILENAME));
                            ContainerUtil.configure((PDFTranscoder) transcoder, config);
                        }
                        default ->
                            throw new TranscoderException("invalid output format: " + getOutputFormat().get().toString());
                    }

// Step 4: write output to target format
                    transcoder.transcode(inputSvgImage, imageOutput);

// Step 5: close and flush output stream
                    imageOutputStream.flush();
                    imageOutputStream.close();
                    try ( OutputStream fileOutputStream = new FileOutputStream(outputFile);) {
                        imageOutputStream.writeTo(fileOutputStream);
                    }
                } catch (IOException | TranscoderException | ConfigurationException e) {
                    System.out.println("failed to generate " + outputFilename);
//                    e.printStackTrace();
                }
            }
        });
    }

}

Ignore Space Show notes View buildSrc/src/main/java/nz/stanger/lecture/GenerateImageFromSourceTask.java 0 → 100644
package nz.stanger.lecture; import groovy.lang.Closure; import java.util.Set; import org.gradle.api.DefaultTask; import org.gradle.api.NonNullApi; import org.gradle.api.file.ConfigurableFileTree; import org.gradle.api.file.DirectoryProperty; import org.gradle.api.file.FileTreeElement; import org.gradle.api.provider.Property; import org.gradle.api.specs.Spec; import org.gradle.api.tasks.IgnoreEmptyDirectories; import org.gradle.api.tasks.InputFiles; import org.gradle.api.tasks.Internal; import org.gradle.api.tasks.OutputDirectory; import org.gradle.api.tasks.PathSensitive; import org.gradle.api.tasks.PathSensitivity; import org.gradle.api.tasks.util.PatternFilterable; import org.gradle.work.DisableCachingByDefault; import org.gradle.work.Incremental; /** * Custom task to generate images from text-based source formats, like PlantUML * or SVG. Apparently we shouldn't extend {@code SourceTask}, as Gradle wants to * move away from extending task types and SourceTask is at some point going to * disappear: * {@link https://github.com/gradle/gradle/issues/11461#issuecomment-560392782} * * This is based on how {@code SourceTask} does things, but without the instance * variables, as they aren't needed and make things more complex than necessary. * {@link https://github.com/gradle/gradle/blob/master/subprojects/core/src/main/java/org/gradle/api/tasks/SourceTask.java} * * In particular, {@code ConvertImageTask} implements {@code PatternFilterable} * so that it can have consistent {@code include} and {@code exclude} methods. * We don't need the separate internal {@code PatternSet} that * {@code SourceTask} has because we're using {@code ConfigurableFileTree} * (which implements {@code PatternFilterable}) instead of * {@code ConfigurableFileCollection}. * * @see org.gradle.api.file.ConfigurableFileTree * @see org.gradle.api.tasks.SourceTask * @see org.gradle.api.tasks.util.PatternFilterable / @NonNullApi @DisableCachingByDefault(because = "Super-class, not to be instantiated directly") abstract public class GenerateImageFromSourceTask extends DefaultTask implements PatternFilterable { /* * Bitmap image transcoder hint: DPI of output image. 200 dpi looks * reasonable. {@link https://stackoverflow.com/a/63684055} / public static final Integer OUTPUT_DPI = 200; /* * Bitmap image transcoder hint: scaled resolution of output image. * {@link https://stackoverflow.com/a/63684055} / public static final Float SCALE_BY_RESOLUTION = OUTPUT_DPI / 72f; /* * Bitmap image transcoder hint: scaled pixel size of output image. * {@link https://stackoverflow.com/a/63684055} / public static final Float PIXEL_UNIT_TO_MM = 25.4f / OUTPUT_DPI; /* * Name of the FOP configuration file. / public static final String FOP_CONFIG_FILENAME = "fopconfig.xml"; /* * Output format of the generated image. / private final Property<ImageFormat> outputFormat = getProject().getObjects().property(ImageFormat.class); /* * Returns the source for this task. Ignores source files which do not * exist. * * @return the source / @InputFiles @IgnoreEmptyDirectories @PathSensitive(PathSensitivity.NAME_ONLY) @Incremental abstract public ConfigurableFileTree getSource(); /* * Returns the output directory for this task. * * @return the output directory / @OutputDirectory abstract public DirectoryProperty getOutputDir(); /* * Returns the output format for this task. * * @return the output format / @Internal public Property<ImageFormat> getOutputFormat() { return outputFormat; } /* * Sets the output format for this task. * * @param format a string value that matches the {@code ImageFormat} enum * @see stanger.nz.lecture.ImageFormat / public void setOutputFormat(String format) { outputFormat.set(ImageFormat.valueOf(format.toUpperCase())); } /* * {@inheritDoc} / @Override public PatternFilterable include(String... includes) { getSource().include(includes); return this; } /* * {@inheritDoc} / @Override public PatternFilterable include(Iterable<String> includes) { getSource().include(includes); return this; } /* * {@inheritDoc} / @Override public PatternFilterable include(Spec<FileTreeElement> includeSpec) { getSource().include(includeSpec); return this; } /* * {@inheritDoc} / @Override public PatternFilterable include(Closure includeSpec) { getSource().include(includeSpec); return this; } /* * {@inheritDoc} / @Override public PatternFilterable exclude(String... excludes) { getSource().exclude(excludes); return this; } /* * {@inheritDoc} / @Override public PatternFilterable exclude(Iterable<String> excludes) { getSource().exclude(excludes); return this; } /* * {@inheritDoc} / @Override public PatternFilterable exclude(Spec<FileTreeElement> excludeSpec) { getSource().exclude(excludeSpec); return this; } /* * {@inheritDoc} / @Override public GenerateImageFromSourceTask exclude(Closure excludeSpec) { getSource().exclude(excludeSpec); return this; } /* * {@inheritDoc} / @Internal @Override public Set<String> getIncludes() { return getSource().getIncludes(); } /* * {@inheritDoc} / @Override public PatternFilterable setIncludes(Iterable<String> includes) { getSource().setIncludes(includes); return this; } /* * {@inheritDoc} / @Internal @Override public Set<String> getExcludes() { return getSource().getExcludes(); } /* * {@inheritDoc} */ @Override public PatternFilterable setExcludes(Iterable<String> excludes) { getSource().setExcludes(excludes); return this; } }

Ignore Space Show notes View

buildSrc/src/main/java/nz/stanger/lecture/GenerateImageFromSourceTask.java 0 → 100644

package nz.stanger.lecture;

import groovy.lang.Closure;
import java.util.Set;
import org.gradle.api.DefaultTask;
import org.gradle.api.NonNullApi;
import org.gradle.api.file.ConfigurableFileTree;
import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.file.FileTreeElement;
import org.gradle.api.provider.Property;
import org.gradle.api.specs.Spec;
import org.gradle.api.tasks.IgnoreEmptyDirectories;
import org.gradle.api.tasks.InputFiles;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.OutputDirectory;
import org.gradle.api.tasks.PathSensitive;
import org.gradle.api.tasks.PathSensitivity;
import org.gradle.api.tasks.util.PatternFilterable;
import org.gradle.work.DisableCachingByDefault;
import org.gradle.work.Incremental;

/**
 * Custom task to generate images from text-based source formats, like PlantUML
 * or SVG. Apparently we shouldn't extend {@code SourceTask}, as Gradle wants to
 * move away from extending task types and SourceTask is at some point going to
 * disappear:
 * {@link https://github.com/gradle/gradle/issues/11461#issuecomment-560392782}
 *
 * This is based on how {@code SourceTask} does things, but without the instance
 * variables, as they aren't needed and make things more complex than necessary.
 * {@link https://github.com/gradle/gradle/blob/master/subprojects/core/src/main/java/org/gradle/api/tasks/SourceTask.java}
 *
 * In particular, {@code ConvertImageTask} implements {@code PatternFilterable}
 * so that it can have consistent {@code include} and {@code exclude} methods.
 * We don't need the separate internal {@code PatternSet} that
 * {@code SourceTask} has because we're using {@code ConfigurableFileTree}
 * (which implements {@code PatternFilterable}) instead of
 * {@code ConfigurableFileCollection}.
 *
 * @see org.gradle.api.file.ConfigurableFileTree
 * @see org.gradle.api.tasks.SourceTask
 * @see org.gradle.api.tasks.util.PatternFilterable
 */
@NonNullApi
@DisableCachingByDefault(because = "Super-class, not to be instantiated directly")
abstract public class GenerateImageFromSourceTask extends DefaultTask implements PatternFilterable {

/**
     * Bitmap image transcoder hint: DPI of output image. 200 dpi looks
     * reasonable. {@link https://stackoverflow.com/a/63684055}
     */
    public static final Integer OUTPUT_DPI = 200;

/**
     * Bitmap image transcoder hint: scaled resolution of output image.
     * {@link https://stackoverflow.com/a/63684055}
     */
    public static final Float SCALE_BY_RESOLUTION = OUTPUT_DPI / 72f;

/**
     * Bitmap image transcoder hint: scaled pixel size of output image.
     * {@link https://stackoverflow.com/a/63684055}
     */
    public static final Float PIXEL_UNIT_TO_MM = 25.4f / OUTPUT_DPI;

/**
     * Name of the FOP configuration file.
     */
    public static final String FOP_CONFIG_FILENAME = "fopconfig.xml";

/**
     * Output format of the generated image.
     */
    private final Property<ImageFormat> outputFormat = getProject().getObjects().property(ImageFormat.class);

/**
     * Returns the source for this task. Ignores source files which do not
     * exist.
     *
     * @return the source
     */
    @InputFiles
    @IgnoreEmptyDirectories
    @PathSensitive(PathSensitivity.NAME_ONLY)
    @Incremental
    abstract public ConfigurableFileTree getSource();

/**
     * Returns the output directory for this task.
     *
     * @return the output directory
     */
    @OutputDirectory
    abstract public DirectoryProperty getOutputDir();

/**
     * Returns the output format for this task.
     *
     * @return the output format
     */
    @Internal
    public Property<ImageFormat> getOutputFormat() {
        return outputFormat;
    }

/**
     * Sets the output format for this task.
     *
     * @param format a string value that matches the {@code ImageFormat} enum
     * @see stanger.nz.lecture.ImageFormat
     */
    public void setOutputFormat(String format) {
        outputFormat.set(ImageFormat.valueOf(format.toUpperCase()));
    }

/**
     * {@inheritDoc}
     */
    @Override
    public PatternFilterable include(String... includes) {
        getSource().include(includes);
        return this;
    }

/**
     * {@inheritDoc}
     */
    @Override
    public PatternFilterable include(Iterable<String> includes) {
        getSource().include(includes);
        return this;
    }

/**
     * {@inheritDoc}
     */
    @Override
    public PatternFilterable include(Spec<FileTreeElement> includeSpec) {
        getSource().include(includeSpec);
        return this;
    }

/**
     * {@inheritDoc}
     */
    @Override
    public PatternFilterable include(Closure includeSpec) {
        getSource().include(includeSpec);
        return this;
    }

/**
     * {@inheritDoc}
     */
    @Override
    public PatternFilterable exclude(String... excludes) {
        getSource().exclude(excludes);
        return this;
    }

/**
     * {@inheritDoc}
     */
    @Override
    public PatternFilterable exclude(Iterable<String> excludes) {
        getSource().exclude(excludes);
        return this;
    }

/**
     * {@inheritDoc}
     */
    @Override
    public PatternFilterable exclude(Spec<FileTreeElement> excludeSpec) {
        getSource().exclude(excludeSpec);
        return this;
    }

/**
     * {@inheritDoc}
     */
    @Override
    public GenerateImageFromSourceTask exclude(Closure excludeSpec) {
        getSource().exclude(excludeSpec);
        return this;
    }

/**
     * {@inheritDoc}
     */
    @Internal
    @Override
    public Set<String> getIncludes() {
        return getSource().getIncludes();
    }

/**
     * {@inheritDoc}
     */
    @Override
    public PatternFilterable setIncludes(Iterable<String> includes) {
        getSource().setIncludes(includes);
        return this;
    }

/**
     * {@inheritDoc}
     */
    @Internal
    @Override
    public Set<String> getExcludes() {
        return getSource().getExcludes();
    }

/**
     * {@inheritDoc}
     */
    @Override
    public PatternFilterable setExcludes(Iterable<String> excludes) {
        getSource().setExcludes(excludes);
        return this;
    }

}

Ignore Space Show notes View buildSrc/src/main/java/nz/stanger/lecture/GenerateImageFromSvgTask.java 0 → 100644
package nz.stanger.lecture; import java.awt.Color; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import java.io.StringReader; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.util.Map; import java.util.Set; import org.apache.batik.anim.dom.SAXSVGDocumentFactory; import org.apache.batik.transcoder.SVGAbstractTranscoder; import org.apache.batik.transcoder.Transcoder; import org.apache.batik.transcoder.TranscoderException; import org.apache.batik.transcoder.TranscoderInput; import org.apache.batik.transcoder.TranscoderOutput; import org.apache.batik.transcoder.image.ImageTranscoder; import org.apache.batik.transcoder.image.PNGTranscoder; import org.apache.batik.util.XMLResourceDescriptor; import org.apache.commons.io.FilenameUtils; import org.apache.fop.activity.ContainerUtil; import org.apache.fop.configuration.Configuration; import org.apache.fop.configuration.ConfigurationException; import org.apache.fop.configuration.DefaultConfigurationBuilder; import org.apache.fop.svg.PDFTranscoder; import org.gradle.api.file.DirectoryProperty; import org.gradle.api.file.FileType; import org.gradle.api.tasks.TaskAction; import org.gradle.work.ChangeType; import org.gradle.work.InputChanges; import org.w3c.dom.svg.SVGDocument; import org.w3c.dom.svg.SVGElement; /** * Generate PDF or PNG output from SVG source. * * See {@link https://plantuml.com/api} for details. / abstract public class GenerateImageFromSvgTask extends GenerateImageFromSourceTask { /* * Files to include in this task. These are Ant-style include and exclude * patterns as per {@code PatternFilterable}. They can be modified by * further calls to {@code include} or {@code exclude}, or replaced entirely * by calling {@code setIncludes}. * * @see org.gradle.api.tasks.util.PatternFilterable / private static final Set<String> INCLUDE_FILES = Set.of(".svg"); /** * Maps image formats to corresponding Batik transcoders. / private static final Map<ImageFormat, Transcoder> TRANSCODERS = Map.of( ImageFormat.PDF, new PDFTranscoder(), ImageFormat.PNG, new PNGTranscoder() ); /* * Constructs a task to generate images from SVG input. / public GenerateImageFromSvgTask() { DirectoryProperty imageDir = getProject().getExtensions().getByType(LectureExtension.class).getImageDir(); getSource().setDir(imageDir); include(INCLUDE_FILES); getOutputDir().convention(imageDir); getOutputFormat().convention(ImageFormat.PDF); setGroup(Lecture.LECTURE_TASK_GROUP); } /* * Runs this task. * * @param inputChanges the inputs that have changed / @TaskAction public void runTask(InputChanges inputChanges) { inputChanges.getFileChanges(getSource()).forEach(change -> { if (change.getFileType() != FileType.DIRECTORY && change.getChangeType() != ChangeType.REMOVED) { String inputFilename = change.getNormalizedPath(); String outputFilename = FilenameUtils.removeExtension(inputFilename) + getOutputFormat().get().getFileSuffix(); try { File outputFile = getOutputDir().file(outputFilename).get().getAsFile(); String svgSource = Files.readString(change.getFile().toPath(), StandardCharsets.UTF_8); // https://xmlgraphics.apache.org/batik/using/dom-api.html String parser = XMLResourceDescriptor.getXMLParserClassName(); SAXSVGDocumentFactory factory = new SAXSVGDocumentFactory(parser); // https://www.programcreek.com/java-api-examples/?api=org.apache.batik.dom.svg.SAXSVGDocumentFactory SVGDocument svgDocument = factory.createSVGDocument(null, new StringReader(svgSource)); // https://thinktibits.blogspot.com/2012/12/batik-convert-svg-to-pdf-java-example.html // Step 1: read input SVG document into TranscoderInput. TranscoderInput inputSvgImage = new TranscoderInput(svgDocument); // Step 2: define OutputStream to target image and attach to TranscoderOutput ByteArrayOutputStream imageOutputStream = new ByteArrayOutputStream(); TranscoderOutput imageOutput = new TranscoderOutput(imageOutputStream); // Step 3: create appropriate image Transcoder. Transcoder transcoder = TRANSCODERS.get(getOutputFormat().get()); switch (getOutputFormat().get()) { case PNG -> { // The raster images that PlantUML generates look like shit // because they're only 72 DPI, and PlantUML provides no way // to specify higher DPI. The solution is to rasterise the // SVG at higher DPI and scale the width and height accordingly. SVGElement svgRoot = svgDocument.getRootElement(); // The width and height attributes may have units, // most likely "px". Just strip out anything that's // not a number Float scaledWidth = Float.valueOf(svgRoot.getAttribute("width").replaceAll("[^\\d]+", "")) SCALE_BY_RESOLUTION; Float scaledHeight = Float.valueOf(svgRoot.getAttribute("height").replaceAll("[^\\d]+", "")) * SCALE_BY_RESOLUTION; transcoder.addTranscodingHint(ImageTranscoder.KEY_BACKGROUND_COLOR, Color.WHITE); transcoder.addTranscodingHint(ImageTranscoder.KEY_WIDTH, scaledWidth); transcoder.addTranscodingHint(ImageTranscoder.KEY_HEIGHT, scaledHeight); transcoder.addTranscodingHint(ImageTranscoder.KEY_PIXEL_UNIT_TO_MILLIMETER, PIXEL_UNIT_TO_MM); } case PDF -> { // This seems to be necessary to ensure properly // embedded fonts when generating PDFs. transcoder.addTranscodingHint(SVGAbstractTranscoder.KEY_DEFAULT_FONT_FAMILY, "Open Sans, Helvetica, Verdana, Arial, sans serif"); // See https://stackoverflow.com/q/47884893 and https://stackoverflow.com/a/72807651 DefaultConfigurationBuilder configBuilder = new DefaultConfigurationBuilder(); // See https://stackoverflow.com/a/20389418 Configuration config = configBuilder.build(getClass().getResourceAsStream("/" + FOP_CONFIG_FILENAME)); ContainerUtil.configure((PDFTranscoder) transcoder, config); } default -> throw new TranscoderException("invalid output format: " + getOutputFormat().get().toString()); } // Step 4: write output to target format transcoder.transcode(inputSvgImage, imageOutput); // Step 5: close and flush output stream imageOutputStream.flush(); imageOutputStream.close(); try ( OutputStream fileOutputStream = new FileOutputStream(outputFile);) { imageOutputStream.writeTo(fileOutputStream); } } catch (IOException \| TranscoderException \| ConfigurationException e) { System.out.println("failed to generate " + outputFilename); // e.printStackTrace(); } } }); } }

Ignore Space Show notes View

buildSrc/src/main/java/nz/stanger/lecture/GenerateImageFromSvgTask.java 0 → 100644

package nz.stanger.lecture;

import java.awt.Color;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.Map;
import java.util.Set;
import org.apache.batik.anim.dom.SAXSVGDocumentFactory;
import org.apache.batik.transcoder.SVGAbstractTranscoder;
import org.apache.batik.transcoder.Transcoder;
import org.apache.batik.transcoder.TranscoderException;
import org.apache.batik.transcoder.TranscoderInput;
import org.apache.batik.transcoder.TranscoderOutput;
import org.apache.batik.transcoder.image.ImageTranscoder;
import org.apache.batik.transcoder.image.PNGTranscoder;
import org.apache.batik.util.XMLResourceDescriptor;
import org.apache.commons.io.FilenameUtils;
import org.apache.fop.activity.ContainerUtil;
import org.apache.fop.configuration.Configuration;
import org.apache.fop.configuration.ConfigurationException;
import org.apache.fop.configuration.DefaultConfigurationBuilder;
import org.apache.fop.svg.PDFTranscoder;
import org.gradle.api.file.DirectoryProperty;
import org.gradle.api.file.FileType;
import org.gradle.api.tasks.TaskAction;
import org.gradle.work.ChangeType;
import org.gradle.work.InputChanges;
import org.w3c.dom.svg.SVGDocument;
import org.w3c.dom.svg.SVGElement;

/**
 * Generate PDF or PNG output from SVG source.
 *
 * See {@link https://plantuml.com/api} for details.
 */
abstract public class GenerateImageFromSvgTask extends GenerateImageFromSourceTask {

/**
     * Constructs a task to generate images from SVG input.
     */
    public GenerateImageFromSvgTask() {
        DirectoryProperty imageDir = getProject().getExtensions().getByType(LectureExtension.class).getImageDir();
        getSource().setDir(imageDir);
        include(INCLUDE_FILES);
        getOutputDir().convention(imageDir);
        getOutputFormat().convention(ImageFormat.PDF);
        setGroup(Lecture.LECTURE_TASK_GROUP);
    }

/**
     * Runs this task.
     *
     * @param inputChanges the inputs that have changed
     */
    @TaskAction
    public void runTask(InputChanges inputChanges) {
        inputChanges.getFileChanges(getSource()).forEach(change -> {
            if (change.getFileType() != FileType.DIRECTORY && change.getChangeType() != ChangeType.REMOVED) {
                String inputFilename = change.getNormalizedPath();
                String outputFilename = FilenameUtils.removeExtension(inputFilename) + getOutputFormat().get().getFileSuffix();

try {
                    File outputFile = getOutputDir().file(outputFilename).get().getAsFile();

String svgSource = Files.readString(change.getFile().toPath(), StandardCharsets.UTF_8);

// Step 3: create appropriate image Transcoder.
                    Transcoder transcoder = TRANSCODERS.get(getOutputFormat().get());

switch (getOutputFormat().get()) {
                        case PNG -> {
                            // The raster images that PlantUML generates look like shit
                            // because they're only 72 DPI, and PlantUML provides no way
                            // to specify higher DPI. The solution is to rasterise the
                            // SVG at higher DPI and scale the width and height accordingly.
                            SVGElement svgRoot = svgDocument.getRootElement();
                            // The width and height attributes may have units,
                            // most likely "px". Just strip out anything that's
                            // not a number
                            Float scaledWidth = Float.valueOf(svgRoot.getAttribute("width").replaceAll("[^\\d]+", "")) * SCALE_BY_RESOLUTION;
                            Float scaledHeight = Float.valueOf(svgRoot.getAttribute("height").replaceAll("[^\\d]+", "")) * SCALE_BY_RESOLUTION;
                            transcoder.addTranscodingHint(ImageTranscoder.KEY_BACKGROUND_COLOR, Color.WHITE);
                            transcoder.addTranscodingHint(ImageTranscoder.KEY_WIDTH, scaledWidth);
                            transcoder.addTranscodingHint(ImageTranscoder.KEY_HEIGHT, scaledHeight);
                            transcoder.addTranscodingHint(ImageTranscoder.KEY_PIXEL_UNIT_TO_MILLIMETER, PIXEL_UNIT_TO_MM);
                        }
                        case PDF -> {
                            // This seems to be necessary to ensure properly
                            // embedded fonts when generating PDFs.
                            transcoder.addTranscodingHint(SVGAbstractTranscoder.KEY_DEFAULT_FONT_FAMILY, "Open Sans, Helvetica, Verdana, Arial, sans serif");
                            // See https://stackoverflow.com/q/47884893 and https://stackoverflow.com/a/72807651
                            DefaultConfigurationBuilder configBuilder = new DefaultConfigurationBuilder();
                            // See https://stackoverflow.com/a/20389418
                            Configuration config = configBuilder.build(getClass().getResourceAsStream("/" + FOP_CONFIG_FILENAME));
                            ContainerUtil.configure((PDFTranscoder) transcoder, config);
                        }
                        default -> throw new TranscoderException("invalid output format: " + getOutputFormat().get().toString());
                    }

// Step 4: write output to target format
                    transcoder.transcode(inputSvgImage, imageOutput);

}

Ignore Space Show notes View buildSrc/src/main/java/nz/stanger/lecture/ImageFormat.java 0 → 100644
package nz.stanger.lecture; /** * Image formats generated by the image generation tasks. / public enum ImageFormat { EPS("application/postscript"), JPEG("image/jpeg"), JPG("image/jpeg"), PDF("application/pdf"), PNG("image/png"), SVG("image/svg+xml"); /* * The MIME type of this image format. / private final String mimeType; /* * Constructs an image format. * * @param mimeType the MIME type of this image format / ImageFormat(String mimeType) { this.mimeType = mimeType; } /* * Returns the MIME type of this image format. * * @return the MIME type / public String getMimeType() { return mimeType; } /* * Returns a file suffix corresponding to this image format, suitable for * appending to a file name. * * @return the file suffix prefixed with a ".", for example {@code .svg} */ public String getFileSuffix() { String suffix = ""; switch (this) { case EPS -> suffix = ".eps"; case JPEG, JPG -> suffix = ".jpg"; case PDF -> suffix = ".pdf"; case PNG -> suffix = ".png"; case SVG -> suffix = ".svg"; default -> throw new IllegalArgumentException("unknown image type: " + this.name()); } return suffix; } }

Ignore Space Show notes View

buildSrc/src/main/java/nz/stanger/lecture/ImageFormat.java 0 → 100644

package nz.stanger.lecture;

/**
 * Image formats generated by the image generation tasks.
 */
public enum ImageFormat {
    EPS("application/postscript"),
    JPEG("image/jpeg"),
    JPG("image/jpeg"),
    PDF("application/pdf"),
    PNG("image/png"),
    SVG("image/svg+xml");

/**
     * The MIME type of this image format.
     */
    private final String mimeType;

/**
     * Constructs an image format.
     *
     * @param mimeType the MIME type of this image format
     */
    ImageFormat(String mimeType) {
        this.mimeType = mimeType;
    }

/**
     * Returns the MIME type of this image format.
     *
     * @return the MIME type
     */
    public String getMimeType() {
        return mimeType;
    }

/**
     * Returns a file suffix corresponding to this image format, suitable for
     * appending to a file name.
     *
     * @return the file suffix prefixed with a ".", for example {@code .svg}
     */
    public String getFileSuffix() {
        String suffix = "";
        switch (this) {
            case EPS ->
                suffix = ".eps";
            case JPEG, JPG ->
                suffix = ".jpg";
            case PDF ->
                suffix = ".pdf";
            case PNG ->
                suffix = ".png";
            case SVG ->
                suffix = ".svg";
            default ->
                throw new IllegalArgumentException("unknown image type: " + this.name());
        }
        return suffix;
    }
}

Ignore Space Show notes View buildSrc/src/main/java/nz/stanger/lecture/Lecture.java
package nz.stanger.lecture; import java.io.File; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.List; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; import org.danilopianini.gradle.latex.LatexExtension; import org.gradle.api.Plugin; import org.gradle.api.Project; import org.gradle.api.file.ConfigurableFileTree; import org.gradle.api.file.Directory; import org.gradle.api.provider.Provider; import org.gradle.api.tasks.Copy; import org.gradle.api.tasks.Delete; import org.gradle.api.tasks.Exec; import org.gradle.api.tasks.TaskContainer; /** * Gradle plugin to implement LaTeX lecture building infrastructure. / public class Lecture implements Plugin<Project> { /* * Default group for lecture related tasks. / public static final String LECTURE_TASK_GROUP = "lecture"; // Internal names for tasks. private static final String UNNUMBERED_TASK_NAME = "docs"; private static final String NUMBERED_TASK_NAME = "numbered"; private static final String IMAGES_TASK_NAME = "images"; private static final String CLEAN_TASK_NAME = "clean"; private static final String DEEP_CLEAN_TASK_NAME = "deepClean"; private static final String DEBUG_TASK_NAME = "debug"; private static final String PDFLATEX_TASK_NAME = "pdfLatex"; // Name of the lecture plugin extension. private static final String LECTURE_EXTENSION_NAME = "lecture"; // Names of document targets. private static final String CONTENT_TARGET_NAME = "content"; private static final String SLIDES_TARGET_NAME = "slides"; private static final String HANDOUT_TARGET_NAME = "handout"; private static final String NOTES_TARGET_NAME = "notes"; private static final String EXAMPLES_TARGET_NAME = "examples"; private static final String NUMBERED_TARGET_SUFFIX = "numbered"; // Prefix of generated lecture document files. private static final String LECTURE_PREFIX = "lecture"; // Only these target names can be used. private static final Set<String> VALID_TARGET_NAMES = Set.of( SLIDES_TARGET_NAME, HANDOUT_TARGET_NAME, NOTES_TARGET_NAME, EXAMPLES_TARGET_NAME ); // Standard directory names. private static final String IMAGES_DIRECTORY = "images"; private static final String PDFS_DIRECTORY = "pdfs"; // Some handy references that are used a lot. private TaskContainer projectTasks; private Directory projectDirectory; private LectureExtension lectureExtension; private LatexExtension latexExtension; /* * Find directories whose names match a regular expression. * * Adapted from {@link https://gist.github.com/Ethsaam/2b8dd748fcc25e6973bb}. * * @param dir the directory to start the search in * @param pattern regular expression to match directory names * @return the collection of matching directories / private Collection<File> getListOfDirectories(Directory dir, String pattern) { return new ArrayList<>(Arrays.asList(dir.getAsFile().listFiles(file -> file.isDirectory() && file.getName().matches(pattern)))); } /* * Applies the plugin. * * @param project the project to apply the plugin to / @Override public void apply(Project project) { projectTasks = project.getTasks(); projectDirectory = project.getLayout().getProjectDirectory(); project.getPluginManager().apply("org.danilopianini.gradle-latex"); // Plugin extensions. lectureExtension = project.getExtensions().create(LECTURE_EXTENSION_NAME, LectureExtension.class); latexExtension = project.getExtensions().getByType(LatexExtension.class); // Configure LaTeX extension. latexExtension.getPdfLatexCommand().set("xelatex"); /* * Set plugin defaults. * * Supported document targets. / lectureExtension.getDocTargets().convention(VALID_TARGET_NAMES); // Validate document target configuration. Must be afterEvaluate() to // ensure everything has been finalised. project.afterEvaluate(p -> { lectureExtension.getDocTargets().get().stream().forEach(target -> { if (!VALID_TARGET_NAMES.contains(target)) { throw new RuntimeException("unsupported target name " + target); } }); }); // Supported targets (numbered documents). Automatically derived from // LectureExtension.docTargets. Provider<Set<String>> numberedDocTargets = lectureExtension.getDocTargets().map( docTargets -> docTargets.stream().map(target -> target + "." + NUMBERED_TARGET_SUFFIX).collect(Collectors.toSet()) ); // Standard lecture prefix string. lectureExtension.getDocPrefix().convention(LECTURE_PREFIX); lectureExtension.getLectureNum().convention(project.getName().substring(0, 2)); // Standard document names (unnumbered). Automatically derived from // LectureExtension.docTargets, plus "content". Provider<Map<String, String>> docNames = lectureExtension.getDocTargets().map(docTargets -> { Map<String, String> names = new HashMap<>(); docTargets.forEach(target -> names.put(target, lectureExtension.getDocPrefix().get() + "_" + target)); names.put(CONTENT_TARGET_NAME, lectureExtension.getDocPrefix().get() + "_" + CONTENT_TARGET_NAME); return names; }); // Standard document names (numbered). Automatically derived from // LectureExtension.docTargets, plus "content". Provider<Map<String, String>> numberedDocNames = lectureExtension.getDocTargets().map(docTargets -> { Map<String, String> names = new HashMap<>(); docTargets.forEach(target -> names.put(target, lectureExtension.getDocPrefix().get() + "_" + lectureExtension.getLectureNum().get() + "_" + target)); names.put(CONTENT_TARGET_NAME, lectureExtension.getDocPrefix().get() + "_" + lectureExtension.getLectureNum().get() + "_" + CONTENT_TARGET_NAME); return names; }); lectureExtension.getImageDir().convention(projectDirectory.dir(IMAGES_DIRECTORY)); lectureExtension.getPdfDir().convention(projectDirectory.dir(PDFS_DIRECTORY)); // slidesImages defaults to empty lectureExtension.getSlidesFiles().convention( lectureExtension.getDocPrefix().map( (String prefix) -> Set.of( prefix + "_" + CONTENT_TARGET_NAME + ".tex", "paper_init.tex", "lecturedates.tex", "doc_init.tex" ) ) ); // examplesImages defaults to empty lectureExtension.getExamplesFiles().convention( lectureExtension.getDocPrefix().map((String prefix) -> { if (lectureExtension.getDocTargets().get().contains(EXAMPLES_TARGET_NAME)) { return Set.of( prefix + "_" + EXAMPLES_TARGET_NAME + ".tex", "paper_init.tex", "lecturedates.tex", "doc_init.tex" ); } else { return Set.of(); } }) ); // Document dependencies. Automatically derived from slidesImages, // slidesFiles, examplesImages, and examplesFiles. Images are mapped to // imageDir. The slides, handout, and notes will always share the same // dependencies. Only the examples will be different. Provider<Set<String>> slideDependencies = lectureExtension.getSlidesImages().map(slideImages -> { Set<String> slideDeps = new HashSet<>(); slideDeps.addAll(slideImages.stream().map(image -> lectureExtension.getImageDir().get() + "/" + image).collect(Collectors.toSet())); slideDeps.addAll(lectureExtension.getSlidesFiles().get()); return slideDeps; }); Provider<Map<String, List<String>>> docDependencies = lectureExtension.getDocTargets().map(docTargets -> { Map<String, List<String>> docDeps = new HashMap<>(); docTargets.forEach(target -> { if (target.equals(EXAMPLES_TARGET_NAME)) { List<String> deps = lectureExtension.getExamplesFiles().get().stream().collect(Collectors.toList()); deps.addAll(lectureExtension.getExamplesImages().get().stream() .map(image -> lectureExtension.getImageDir().get() + "/" + image) .collect(Collectors.toList()) ); docDeps.put(target, deps); } else { docDeps.put(target, slideDependencies.get().stream().collect(Collectors.toList())); } }); return docDeps; }); lectureExtension.getCleanFiles().convention(Set.of( ".aux", ".dvi", ".fdb_latexmk", ".fls", ".head", ".listing", ".log", ".nav", ".out", ".pyg", ".snm", ".synctex.gz", ".tmp", ".toc", ".vrb", ".xdv" )); // These are regular expressions, NOT glob patterns. lectureExtension.getCleanDirs().convention(Set.of( "_minted." )); lectureExtension.getLatexFlags().convention(Set.of( "-shell-escape", "-synctex=1", "-interaction=nonstopmode", "-halt-on-error", "-file-line-error" )); /** * Tasks. * * It doesn't always seem to be strictly necessary, but it seems safer * in general to assume that all tasks need to be afterEvaluate(). It's * certainly necessary for generated tasks that derive from * configuration variables. / project.afterEvaluate(p -> { project.setDefaultTasks(Arrays.asList(UNNUMBERED_TASK_NAME, NUMBERED_TASK_NAME)); // All unnumbered documents. projectTasks.register(UNNUMBERED_TASK_NAME, task -> { task.setDescription("Build all documents (draft, unnumbered)."); task.setGroup(LECTURE_TASK_GROUP); task.dependsOn(lectureExtension.getDocTargets()); }); // Generate tasks for each of the unnumbered document targets. // All generated tasks that derive from configuration variables must be // afterEvaluate() to ensure everything has been finalised. lectureExtension.getDocTargets().get().forEach(target -> { projectTasks.register(target, task -> { task.setDescription("Build " + target + " document (draft, unnumbered)."); task.setGroup(LECTURE_TASK_GROUP); task.dependsOn(PDFLATEX_TASK_NAME + "." + docNames.get().get(target)); }); }); // All numbered documents. projectTasks.register(NUMBERED_TASK_NAME, task -> { task.setDescription("Build all documents (final, numbered)."); task.setGroup(LECTURE_TASK_GROUP); task.dependsOn(numberedDocTargets); }); // Generate tasks for each of the numbered document targets. numberedDocTargets.get().forEach(target -> { projectTasks.register(target, Copy.class, task -> { String baseTarget = target.replace("." + NUMBERED_TARGET_SUFFIX, ""); task.setDescription("Build " + baseTarget + " document (final, numbered)."); task.setGroup(LECTURE_TASK_GROUP); task.from(project.getTasksByName(PDFLATEX_TASK_NAME + "." + docNames.get().get(baseTarget), true)); task.into(lectureExtension.getPdfDir()); // The LaTeX tasks include the .aux file in their outputs. // Exclude or they will also be copied into the PDFs directory. task.exclude(".aux"); task.rename(src -> src.replace("_", "_" + lectureExtension.getLectureNum().get() + "_")); }); }); // Generate LaTeX build tasks for each of the targets. This uses the // string invocation method supplied by the LaTeX plugin. lectureExtension.getDocTargets().get().forEach(target -> { latexExtension.invoke(docNames.get().get(target), (dsl) -> { dsl.setExtraArguments(lectureExtension.getLatexFlags().get()); dsl.setWatching(docDependencies.get().get(target)); return null; // workaround for Kotlin Unit (void) return }); }); // All generated images. Depends on any additional image generation // sub-tasks. projectTasks.register(IMAGES_TASK_NAME, task -> { task.setDescription("Generate images."); task.setGroup(LECTURE_TASK_GROUP); task.setDependsOn(projectTasks.withType(GenerateImageFromSourceTask.class)); }); // Ensure that the LaTeX tasks depend on the images task. This implies // that all LaTeX documents dependent on all generated images, // even when a document doesn't actually depend on a specific image. // This would be too much of a hassle to fix given the relatively // small benefit. projectTasks.matching(task -> task.getName().startsWith(PDFLATEX_TASK_NAME)).forEach(pdfLatexTask -> { pdfLatexTask.dependsOn(projectTasks.getByName(IMAGES_TASK_NAME)); }); // Remove files specified in cleanFiles and directories specified // in cleanDirs. projectTasks.register(CLEAN_TASK_NAME, Delete.class, task -> { task.setDescription("Clean up intermediate files."); task.setGroup(LECTURE_TASK_GROUP); ConfigurableFileTree tree = project.fileTree(projectDirectory); tree.include(lectureExtension.getCleanFiles().get()); task.delete(tree); lectureExtension.getCleanDirs().get().forEach( pattern -> task.delete(getListOfDirectories(projectDirectory, pattern)) ); }); // Remove everything not under version control. Unfortunately this doesn't // include the .gradle directory :(, but in hindsight that's not surprising. projectTasks.register(DEEP_CLEAN_TASK_NAME, Exec.class, task -> { task.setDescription("Remove all files not in Git."); task.setGroup(LECTURE_TASK_GROUP); task.setCommandLine("git", "clean", "-fXd"); }); }); // Debugging information. projectTasks.register(DEBUG_TASK_NAME, task -> { task.setDescription("Print debugging information."); task.setGroup(LECTURE_TASK_GROUP); task.doLast(s -> { System.out.println("project name = <" + project.getName() + ">"); System.out.println("project directory = <" + projectDirectory + ">"); System.out.println("docTargets = <" + lectureExtension.getDocTargets().get().toString() + ">"); System.out.println("numberedDocTargets = <" + numberedDocTargets.get().toString() + ">"); System.out.println("docPrefix = <" + lectureExtension.getDocPrefix().get() + ">"); System.out.println("lectureNum = <" + lectureExtension.getLectureNum().get() + ">"); System.out.println("docNames = <" + docNames.get().toString() + ">"); System.out.println("numberedDocNames = <" + numberedDocNames.get().toString() + ">"); System.out.println("imageDir = <" + lectureExtension.getImageDir().get().getAsFile().getName() + ">"); System.out.println("pdfDir = <" + lectureExtension.getPdfDir().get().getAsFile().getName() + ">"); System.out.println("slidesImages = <" + lectureExtension.getSlidesImages().get().toString() + ">"); System.out.println("slidesFiles = <" + lectureExtension.getSlidesFiles().get().toString() + ">"); System.out.println("examplesImages = <" + lectureExtension.getExamplesImages().get().toString() + ">"); System.out.println("examplesFiles = <" + lectureExtension.getExamplesFiles().get().toString() + ">"); System.out.println("slideDependencies = <" + slideDependencies.get().toString() + ">"); System.out.println("docDependencies = <" + docDependencies.get().toString() + ">"); System.out.println("cleanFiles = <" + lectureExtension.getCleanFiles().get().toString() + ">"); System.out.println("cleanDirs = <" + lectureExtension.getCleanDirs().get().toString() + ">"); System.out.println("latexFlags = <" + lectureExtension.getLatexFlags().get().toString() + ">"); System.out.println("latex.terminalEmulator = <" + latexExtension.getTerminalEmulator().get() + ">"); System.out.println("latex.waitTime = <" + latexExtension.getWaitTime().get() + ">"); System.out.println("latex.waitUnit = <" + latexExtension.getWaitUnit().get() + ">"); System.out.println("latex.pdfLatexCommand = <" + latexExtension.getPdfLatexCommand().get() + ">"); System.out.println("latex.bibTexCommand = <" + latexExtension.getBibTexCommand().get() + ">"); System.out.println("latex.inkscapeCommand = <" + latexExtension.getInkscapeCommand().get() + ">"); System.out.println("latex.gitLatexdiffCommand = <" + latexExtension.getGitLatexdiffCommand().get() + ">"); }); }); } } package nz.stanger.lecture; import java.io.File; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.List; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; import org.danilopianini.gradle.latex.LatexExtension; import org.gradle.api.Plugin; import org.gradle.api.Project; import org.gradle.api.file.ConfigurableFileTree; import org.gradle.api.file.Directory; import org.gradle.api.provider.Provider; import org.gradle.api.provider.SetProperty; import org.gradle.api.tasks.Copy; import org.gradle.api.tasks.Delete; import org.gradle.api.tasks.Exec; import org.gradle.api.tasks.TaskContainer; public class Lecture implements Plugin<Project> { private static final String CONTENT = "content"; private static final String SLIDES = "slides"; private static final String HANDOUT = "handout"; private static final String NOTES = "notes"; private static final String EXAMPLES = "examples"; private static final String LECTURE_PREFIX = "lecture"; private static final String TASK_GROUP = "Lecture"; private static final Set<String> VALID_TARGET_NAMES = Set.of( SLIDES, HANDOUT, NOTES, EXAMPLES ); // Some handy references that are used a lot. private TaskContainer projectTasks; private Directory projectDirectory; private LectureExtension lecture; private LatexExtension latex; /** * Find directories whose names match a regular expression. * * Adapted from https://gist.github.com/Ethsaam/2b8dd748fcc25e6973bb. * * @param dir the directory to start the search in * @param pattern regular expression matching directory names * @return the collection of matching directories / private Collection<File> getListOfDirectories(Directory dir, String pattern) { return new ArrayList<>(Arrays.asList(dir.getAsFile().listFiles(file -> file.isDirectory() && file.getName().matches(pattern)))); } /* * Register a task to generate an image from some other format. * * @param srcRegex regular expression matching source files (inputs) * @param dstRegex regular expression matching destination files (outputs) * @param cmdTemplate list of command line components (strings) / private void registerGeneratedImageTask(String srcRegex, String dstRegex, List<String> cmdTemplate) { lecture.getGeneratedImages().get().entrySet().stream() .filter(entry -> entry.getValue().matches(srcRegex)) .filter(entry -> entry.getKey().matches(dstRegex)) .forEach(entry -> { File dst = lecture.getImageDir().file(entry.getKey()).get().getAsFile(); File src = lecture.getImageDir().file(entry.getValue()).get().getAsFile(); projectTasks.register("images." + entry.getKey(), Exec.class, task -> { task.setDescription("Generate " + entry.getKey() + " from " + entry.getValue() + "."); task.setGroup(TASK_GROUP); File cropped = lecture.getImageDir().file(entry.getKey().replace(".pdf", "-crop.pdf")).get().getAsFile(); // set working directory to imageDir so that relative // references work, e.g., PlantUML includes task.setWorkingDir(lecture.getImageDir().get()); task.getInputs().files(src); task.getOutputs().files(dst); List<String> command = cmdTemplate.stream().map( part -> part.replaceAll("<<src>>", src.getName()) .replaceAll("<<dst>>", dst.getName()) .replaceAll("<<cropped>>", cropped.getName()) ).collect(Collectors.toList()); task.commandLine(command); }); // Every PDF generation will have a different hash, so only run the // task if the input is newer than the output. projectTasks.getByPath("images." + entry.getKey()).onlyIf(t -> { return src.lastModified() > dst.lastModified(); }); }); } @Override public void apply(Project project) { projectTasks = project.getTasks(); projectDirectory = project.getLayout().getProjectDirectory(); project.getPluginManager().apply("org.danilopianini.gradle-latex"); // Plugin extensions. lecture = project.getExtensions().create("lecture", LectureExtension.class); latex = project.getExtensions().getByType(LatexExtension.class); // Configure LaTeX extension. latex.getPdfLatexCommand().set("xelatex"); /* * Set plugin defaults. / // Supported document targets. lecture.getDocTargets().convention(VALID_TARGET_NAMES); // Validate document target configuration. Must be afterEvaluate() to // ensure everything has been finalised. project.afterEvaluate(p -> { lecture.getDocTargets().get().stream().forEach(target -> { if (!VALID_TARGET_NAMES.contains(target)) { throw new RuntimeException("unsupported target name " + target); } }); }); // Supported targets (numbered documents). Automatically derived from // LectureExtension.docTargets. Provider<Set<String>> numberedDocTargets = lecture.getDocTargets().map( docTargets -> docTargets.stream().map(target -> target + ".numbered").collect(Collectors.toSet()) ); // Standard lecture prefix string. lecture.getDocPrefix().convention(LECTURE_PREFIX); lecture.getLectureNum().convention(project.getName().substring(0, 2)); // Standard document names (unnumbered). Automatically derived from // LectureExtension.docTargets, plus "content". Provider<Map<String, String>> docNames = lecture.getDocTargets().map(docTargets -> { Map<String, String> names = new HashMap<>(); docTargets.forEach(target -> names.put(target, lecture.getDocPrefix().get() + "_" + target)); names.put(CONTENT, lecture.getDocPrefix().get() + "_" + CONTENT); return names; }); // Standard document names (numbered). Automatically derived from // LectureExtension.docTargets, plus "content". Provider<Map<String, String>> numberedDocNames = lecture.getDocTargets().map(docTargets -> { Map<String, String> names = new HashMap<>(); docTargets.forEach(target -> names.put(target, lecture.getDocPrefix().get() + "_" + lecture.getLectureNum().get() + "_" + target)); names.put(CONTENT, lecture.getDocPrefix().get() + "_" + lecture.getLectureNum().get() + "_" + CONTENT); return names; }); lecture.getImageDir().convention(projectDirectory.dir("images")); lecture.getPdfDir().convention(projectDirectory.dir("pdfs")); // slidesImages defaults to empty lecture.getSlidesFiles().convention( lecture.getDocPrefix().map( (String prefix) -> Set.of( prefix + "_" + CONTENT + ".tex", "paper_init.tex", "lecturedates.tex", "doc_init.tex" ) ) ); // examplesImages defaults to empty lecture.getExamplesFiles().convention( lecture.getDocPrefix().map((String prefix) -> { if (lecture.getDocTargets().get().contains(EXAMPLES)) { return Set.of( prefix + "_" + EXAMPLES + ".tex", "paper_init.tex", "lecturedates.tex", "doc_init.tex" ); } else { return Set.of(); } }) ); // Document dependencies. Automatically derived from slidesImages, // slidesFiles, examplesImages, and examplesFiles. Images are mapped to // imageDir. The slides, handout, and notes will always share the same // dependencies. Only the examples will be different. Provider<Set<String>> slideDependencies = lecture.getSlidesImages().map(slideImages -> { Set<String> slideDeps = new HashSet<>(); slideDeps.addAll(slideImages.stream().map(image -> lecture.getImageDir().get() + "/" + image).collect(Collectors.toSet())); slideDeps.addAll(lecture.getSlidesFiles().get()); return slideDeps; }); Provider<Map<String, List<String>>> docDependencies = lecture.getDocTargets().map(docTargets -> { Map<String, List<String>> docDeps = new HashMap<>(); docTargets.forEach(target -> { if (target.equals("examples")) { List<String> deps = lecture.getExamplesFiles().get().stream().collect(Collectors.toList()); deps.addAll(lecture.getExamplesImages().get().stream() .map(image -> lecture.getImageDir().get() + "/" + image) .collect(Collectors.toList()) ); docDeps.put(target, deps); } else { docDeps.put(target, slideDependencies.get().stream().collect(Collectors.toList())); } }); return docDeps; }); // generatedImages defaults to empty lecture.getCleanFiles().convention(Set.of( ".aux", ".dvi", ".fdb_latexmk", ".fls", ".head", ".listing", ".log", ".nav", ".out", ".pyg", ".snm", ".synctex.gz", ".tmp", ".toc", ".vrb", ".xdv" )); // These are regular expressions, NOT glob patterns. lecture.getCleanDirs().convention(Set.of( "_minted." )); lecture.getLatexFlags().convention(Set.of( "-shell-escape", "-synctex=1", "-interaction=nonstopmode", "-halt-on-error", "-file-line-error" )); /** * Tasks. * * It doesn't always seem to be strictly necessary, but it seems safer * in general to assume that all tasks need to be afterEvaluate(). It's * certainly necessary for generated tasks that derive from * configuration variables. / project.afterEvaluate(p -> { project.setDefaultTasks(Arrays.asList("docs", "numbered")); // All unnumbered documents. projectTasks.register("docs", task -> { task.setDescription("Build all documents."); task.setGroup(TASK_GROUP); task.dependsOn(lecture.getDocTargets()); }); // Generate tasks for each of the unnumbered document targets. // All generated tasks that derive from configuration variables must be // afterEvaluate() to ensure everything has been finalised. lecture.getDocTargets().get().forEach(target -> { projectTasks.register(target, task -> { task.setDescription("Build " + target + " document."); task.setGroup(TASK_GROUP); task.dependsOn("pdfLatex." + docNames.get().get(target)); }); }); // All numbered documents. projectTasks.register("numbered", task -> { task.setDescription("Create numbered versions of all documents."); task.setGroup(TASK_GROUP); task.dependsOn(numberedDocTargets); }); // Generate tasks for each of the numbered document targets. numberedDocTargets.get().forEach(target -> { projectTasks.register(target, Copy.class, task -> { String baseTarget = target.replace(".numbered", ""); task.setDescription("Build numbered version of " + baseTarget + " document."); task.setGroup(TASK_GROUP); task.from(project.getTasksByName("pdfLatex." + docNames.get().get(baseTarget), true)); task.into(lecture.getPdfDir()); // The LaTeX tasks include the .aux file in their outputs. // Exclude or they will also be copied into the PDFs directory. task.exclude(".aux"); task.rename(src -> src.replace("_", "_" + lecture.getLectureNum().get() + "_")); }); }); // Generate LaTeX build tasks for each of the targets. This uses the // string invocation method supplied by the LaTeX plugin. lecture.getDocTargets().get().forEach(target -> { latex.invoke(docNames.get().get(target), (dsl) -> { dsl.setExtraArguments(lecture.getLatexFlags().get()); dsl.setWatching(docDependencies.get().get(target)); return null; // workaround for Kotlin Unit (void) return }); }); // Add image task dependencies to the generated LaTeX tasks. // No need to check whether there are any generated images, Gradle does // the right thing if the list is empty. This also makes all LaTeX // documents dependent on all generated images, even when a document // doesn't actually depend on a specific image. This would be too much // of a hassle to fix given the relatively small benefit. projectTasks.matching(task -> task.getName().startsWith("pdfLatex")).forEach(pdfLatexTask -> { pdfLatexTask.dependsOn(projectTasks.matching(t -> t.getName().startsWith("images."))); }); // All generated images. projectTasks.register("images", task -> { task.setDescription("Generate images."); task.setGroup(TASK_GROUP); task.setDependsOn(projectTasks.matching(t -> t.getName().startsWith("images."))); }); // Remove files specified in cleanFiles and directories specified // in cleanDirs. //!! Does this need afterEvaluate()? projectTasks.register("clean", Delete.class, task -> { task.setDescription("Clean up intermediate files."); task.setGroup(TASK_GROUP); ConfigurableFileTree tree = project.fileTree(projectDirectory); tree.include(lecture.getCleanFiles().get()); task.delete(tree); lecture.getCleanDirs().get().forEach( pattern -> task.delete(getListOfDirectories(projectDirectory, pattern)) ); }); // Remove everything not under version control. Unfortunately this doesn't // include the .gradle directory :(, but in hindsight that's not surprising. projectTasks.register("deepClean", Exec.class, task -> { task.setDescription("Remove all files not in Git."); task.setGroup(TASK_GROUP); task.setCommandLine("git", "clean", "-fXd"); }); /** * Per-file tasks to convert images. * * By default these assume single-file inputs, e.g., foo.svg -> * foo.pdf. If you have a file that is dependent on multiple inputs * (e.g., bar.pu -> foo.pu -> foo.pdf), register an independent task * in the lecture's build.gradle.kts by copying the corresponding * registration code below, substituting the actual filenames in * place of the variable references like key and * generatedImages[key]. Also remove the file from generatedImages * to avoid a name clash. You can access properties like imageDir * via project.properties (these will probably need explicit type * casting). / // Generate per-file tasks to convert PlantUML to PDF. registerGeneratedImageTask( ".\\.(pu\|puml\|plantuml)$", ".\\.pdf$", // Direct PDF from PlantUML is problematic, go via SVG instead. new ArrayList<>(Arrays.asList( "bash", "-c", "plantuml -tsvg -pipe < <<src>> \| rsvg-convert --format pdf > <<dst>> && pdfcrop <<dst>> <<cropped>> && mv -f <<cropped>> <<dst>>" )) ); // Generate per-file tasks to convert SVG to PDF. registerGeneratedImageTask( ".\\.svg$", ".\\.pdf$", new ArrayList<>(Arrays.asList( "bash", "-c", "rsvg-convert --format pdf <<src>> > <<dst>> && pdfcrop <<dst>> <<cropped>> && mv -f <<cropped>> <<dst>>" )) ); // Generate per-file tasks to convert R to PDF. registerGeneratedImageTask( ".\\.R$", ".*\\.pdf$", new ArrayList<>(Arrays.asList( "bash", "-c", "R --no-echo --file=<<src>> --args <<dst>> && pdfcrop <<dst>> <<cropped>> && mv -f <<cropped>> <<dst>>" )) ); }); // Debugging information. projectTasks.register("debug", task -> { task.setDescription("Print debugging information."); task.setGroup(TASK_GROUP); task.doLast(s -> { System.out.println("project name = <" + project.getName() + ">"); System.out.println("project directory = <" + projectDirectory + ">"); System.out.println("docTargets = <" + lecture.getDocTargets().get().toString() + ">"); System.out.println("numberedDocTargets = <" + numberedDocTargets.get().toString() + ">"); System.out.println("docPrefix = <" + lecture.getDocPrefix().get() + ">"); System.out.println("lectureNum = <" + lecture.getLectureNum().get() + ">"); System.out.println("docNames = <" + docNames.get().toString() + ">"); System.out.println("numberedDocNames = <" + numberedDocNames.get().toString() + ">"); System.out.println("imageDir = <" + lecture.getImageDir().get().getAsFile().getName() + ">"); System.out.println("pdfDir = <" + lecture.getPdfDir().get().getAsFile().getName() + ">"); System.out.println("slidesImages = <" + lecture.getSlidesImages().get().toString() + ">"); System.out.println("slidesFiles = <" + lecture.getSlidesFiles().get().toString() + ">"); System.out.println("examplesImages = <" + lecture.getExamplesImages().get().toString() + ">"); System.out.println("examplesFiles = <" + lecture.getExamplesFiles().get().toString() + ">"); System.out.println("slideDependencies = <" + slideDependencies.get().toString() + ">"); System.out.println("docDependencies = <" + docDependencies.get().toString() + ">"); System.out.println("generatedImages = <" + lecture.getGeneratedImages().get().toString() + ">"); System.out.println("cleanFiles = <" + lecture.getCleanFiles().get().toString() + ">"); System.out.println("cleanDirs = <" + lecture.getCleanDirs().get().toString() + ">"); System.out.println("latexFlags = <" + lecture.getLatexFlags().get().toString() + ">"); System.out.println("latex.terminalEmulator = <" + latex.getTerminalEmulator().get() + ">"); System.out.println("latex.waitTime = <" + latex.getWaitTime().get() + ">"); System.out.println("latex.waitUnit = <" + latex.getWaitUnit().get() + ">"); System.out.println("latex.pdfLatexCommand = <" + latex.getPdfLatexCommand().get() + ">"); System.out.println("latex.bibTexCommand = <" + latex.getBibTexCommand().get() + ">"); System.out.println("latex.inkscapeCommand = <" + latex.getInkscapeCommand().get() + ">"); System.out.println("latex.gitLatexdiffCommand = <" + latex.getGitLatexdiffCommand().get() + ">"); }); }); } }

Ignore Space Show notes View

buildSrc/src/main/java/nz/stanger/lecture/Lecture.java

package nz.stanger.lecture;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.danilopianini.gradle.latex.LatexExtension;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.file.ConfigurableFileTree;
import org.gradle.api.file.Directory;
import org.gradle.api.provider.Provider;
import org.gradle.api.tasks.Copy;
import org.gradle.api.tasks.Delete;
import org.gradle.api.tasks.Exec;
import org.gradle.api.tasks.TaskContainer;

/**
 * Gradle plugin to implement LaTeX lecture building infrastructure.
 */
public class Lecture implements Plugin<Project> {

/**
     * Default group for lecture related tasks.
     */
    public static final String LECTURE_TASK_GROUP = "lecture";
    
    // Internal names for tasks.
    private static final String UNNUMBERED_TASK_NAME = "docs";
    private static final String NUMBERED_TASK_NAME = "numbered";
    private static final String IMAGES_TASK_NAME = "images";
    private static final String CLEAN_TASK_NAME = "clean";
    private static final String DEEP_CLEAN_TASK_NAME = "deepClean";
    private static final String DEBUG_TASK_NAME = "debug";
    private static final String PDFLATEX_TASK_NAME = "pdfLatex";
    
    // Name of the lecture plugin extension.
    private static final String LECTURE_EXTENSION_NAME = "lecture";

// Names of document targets.
    private static final String CONTENT_TARGET_NAME = "content";
    private static final String SLIDES_TARGET_NAME = "slides";
    private static final String HANDOUT_TARGET_NAME = "handout";
    private static final String NOTES_TARGET_NAME = "notes";
    private static final String EXAMPLES_TARGET_NAME = "examples";
    private static final String NUMBERED_TARGET_SUFFIX = "numbered";

// Prefix of generated lecture document files.
    private static final String LECTURE_PREFIX = "lecture";

// Only these target names can be used.
    private static final Set<String> VALID_TARGET_NAMES = Set.of(
            SLIDES_TARGET_NAME,
            HANDOUT_TARGET_NAME,
            NOTES_TARGET_NAME,
            EXAMPLES_TARGET_NAME
    );
    
    // Standard directory names.
    private static final String IMAGES_DIRECTORY = "images";
    private static final String PDFS_DIRECTORY = "pdfs";

// Some handy references that are used a lot.
    private TaskContainer projectTasks;
    private Directory projectDirectory;
    private LectureExtension lectureExtension;
    private LatexExtension latexExtension;

/**
     * Find directories whose names match a regular expression.
     *
     * Adapted from {@link https://gist.github.com/Ethsaam/2b8dd748fcc25e6973bb}.
     *
     * @param dir the directory to start the search in
     * @param pattern regular expression to match directory names
     * @return the collection of matching directories
     */
    private Collection<File> getListOfDirectories(Directory dir, String pattern) {
        return new ArrayList<>(Arrays.asList(dir.getAsFile().listFiles(file -> file.isDirectory() && file.getName().matches(pattern))));
    }

/**
     * Applies the plugin.
     * 
     * @param project the project to apply the plugin to
     */
    @Override
    public void apply(Project project) {
        projectTasks = project.getTasks();
        projectDirectory = project.getLayout().getProjectDirectory();

project.getPluginManager().apply("org.danilopianini.gradle-latex");

// Plugin extensions.
        lectureExtension = project.getExtensions().create(LECTURE_EXTENSION_NAME, LectureExtension.class);
        latexExtension = project.getExtensions().getByType(LatexExtension.class);

// Configure LaTeX extension.
        latexExtension.getPdfLatexCommand().set("xelatex");

/**
         * Set plugin defaults.
         *
         * Supported document targets.
         */
        lectureExtension.getDocTargets().convention(VALID_TARGET_NAMES);

// Validate document target configuration. Must be afterEvaluate() to
        // ensure everything has been finalised.
        project.afterEvaluate(p -> {
            lectureExtension.getDocTargets().get().stream().forEach(target -> {
                if (!VALID_TARGET_NAMES.contains(target)) {
                    throw new RuntimeException("unsupported target name " + target);
                }
            });
        });

// Supported targets (numbered documents). Automatically derived from
        // LectureExtension.docTargets.
        Provider<Set<String>> numberedDocTargets = lectureExtension.getDocTargets().map(
                docTargets -> docTargets.stream().map(target -> target + "." + NUMBERED_TARGET_SUFFIX).collect(Collectors.toSet())
        );

// Standard lecture prefix string.
        lectureExtension.getDocPrefix().convention(LECTURE_PREFIX);

lectureExtension.getLectureNum().convention(project.getName().substring(0, 2));

// Standard document names (unnumbered). Automatically derived from
        // LectureExtension.docTargets, plus "content".
        Provider<Map<String, String>> docNames = lectureExtension.getDocTargets().map(docTargets -> {
            Map<String, String> names = new HashMap<>();
            docTargets.forEach(target -> names.put(target, lectureExtension.getDocPrefix().get() + "_" + target));
            names.put(CONTENT_TARGET_NAME, lectureExtension.getDocPrefix().get() + "_" + CONTENT_TARGET_NAME);
            return names;
        });

// Standard document names (numbered). Automatically derived from
        // LectureExtension.docTargets, plus "content".
        Provider<Map<String, String>> numberedDocNames = lectureExtension.getDocTargets().map(docTargets -> {
            Map<String, String> names = new HashMap<>();
            docTargets.forEach(target -> names.put(target, lectureExtension.getDocPrefix().get() + "_" + lectureExtension.getLectureNum().get() + "_" + target));
            names.put(CONTENT_TARGET_NAME, lectureExtension.getDocPrefix().get() + "_" + lectureExtension.getLectureNum().get() + "_" + CONTENT_TARGET_NAME);
            return names;
        });

lectureExtension.getImageDir().convention(projectDirectory.dir(IMAGES_DIRECTORY));

lectureExtension.getPdfDir().convention(projectDirectory.dir(PDFS_DIRECTORY));

// slidesImages defaults to empty
        lectureExtension.getSlidesFiles().convention(
                lectureExtension.getDocPrefix().map(
                        (String prefix) -> Set.of(
                                prefix + "_" + CONTENT_TARGET_NAME + ".tex",
                                "paper_init.tex",
                                "lecturedates.tex",
                                "doc_init.tex"
                        )
                )
        );

// examplesImages defaults to empty
        lectureExtension.getExamplesFiles().convention(
                lectureExtension.getDocPrefix().map((String prefix) -> {
                    if (lectureExtension.getDocTargets().get().contains(EXAMPLES_TARGET_NAME)) {
                        return Set.of(
                                prefix + "_" + EXAMPLES_TARGET_NAME + ".tex",
                                "paper_init.tex",
                                "lecturedates.tex",
                                "doc_init.tex"
                        );
                    } else {
                        return Set.of();
                    }
                })
        );

// Document dependencies. Automatically derived from slidesImages,
        // slidesFiles, examplesImages, and examplesFiles. Images are mapped to
        // imageDir. The slides, handout, and notes will always share the same
        // dependencies. Only the examples will be different.
        Provider<Set<String>> slideDependencies = lectureExtension.getSlidesImages().map(slideImages -> {
            Set<String> slideDeps = new HashSet<>();
            slideDeps.addAll(slideImages.stream().map(image -> lectureExtension.getImageDir().get() + "/" + image).collect(Collectors.toSet()));
            slideDeps.addAll(lectureExtension.getSlidesFiles().get());
            return slideDeps;
        });

Provider<Map<String, List<String>>> docDependencies = lectureExtension.getDocTargets().map(docTargets -> {
            Map<String, List<String>> docDeps = new HashMap<>();
            docTargets.forEach(target -> {
                if (target.equals(EXAMPLES_TARGET_NAME)) {
                    List<String> deps = lectureExtension.getExamplesFiles().get().stream().collect(Collectors.toList());
                    deps.addAll(lectureExtension.getExamplesImages().get().stream()
                            .map(image -> lectureExtension.getImageDir().get() + "/" + image)
                            .collect(Collectors.toList())
                    );
                    docDeps.put(target, deps);
                } else {
                    docDeps.put(target, slideDependencies.get().stream().collect(Collectors.toList()));
                }
            });
            return docDeps;
        });

lectureExtension.getCleanFiles().convention(Set.of(
                "*.aux",
                "*.dvi",
                "*.fdb_latexmk",
                "*.fls",
                "*.head",
                "*.listing",
                "*.log",
                "*.nav",
                "*.out",
                "*.pyg",
                "*.snm",
                "*.synctex.gz",
                "*.tmp",
                "*.toc",
                "*.vrb",
                "*.xdv"
        ));
        // These are regular expressions, NOT glob patterns.
        lectureExtension.getCleanDirs().convention(Set.of(
                "_minted.*"
        ));

lectureExtension.getLatexFlags().convention(Set.of(
                "-shell-escape",
                "-synctex=1",
                "-interaction=nonstopmode",
                "-halt-on-error",
                "-file-line-error"
        ));

/**
         * Tasks.
         *
         * It doesn't always seem to be strictly necessary, but it seems safer
         * in general to assume that all tasks need to be afterEvaluate(). It's
         * certainly necessary for generated tasks that derive from
         * configuration variables.
         */
        project.afterEvaluate(p -> {

project.setDefaultTasks(Arrays.asList(UNNUMBERED_TASK_NAME, NUMBERED_TASK_NAME));

// All unnumbered documents.
            projectTasks.register(UNNUMBERED_TASK_NAME, task -> {
                task.setDescription("Build all documents (draft, unnumbered).");
                task.setGroup(LECTURE_TASK_GROUP);
                task.dependsOn(lectureExtension.getDocTargets());
            });

// Generate tasks for each of the unnumbered document targets.
            // All generated tasks that derive from configuration variables must be
            // afterEvaluate() to ensure everything has been finalised.
            lectureExtension.getDocTargets().get().forEach(target -> {
                projectTasks.register(target, task -> {
                    task.setDescription("Build " + target + " document (draft, unnumbered).");
                    task.setGroup(LECTURE_TASK_GROUP);
                    task.dependsOn(PDFLATEX_TASK_NAME + "." + docNames.get().get(target));
                });
            });

// All numbered documents.
            projectTasks.register(NUMBERED_TASK_NAME, task -> {
                task.setDescription("Build all documents (final, numbered).");
                task.setGroup(LECTURE_TASK_GROUP);
                task.dependsOn(numberedDocTargets);
            });

// Generate tasks for each of the numbered document targets.
            numberedDocTargets.get().forEach(target -> {
                projectTasks.register(target, Copy.class, task -> {
                    String baseTarget = target.replace("." + NUMBERED_TARGET_SUFFIX, "");
                    task.setDescription("Build " + baseTarget + " document (final, numbered).");
                    task.setGroup(LECTURE_TASK_GROUP);

task.from(project.getTasksByName(PDFLATEX_TASK_NAME + "." + docNames.get().get(baseTarget), true));
                    task.into(lectureExtension.getPdfDir());

// The LaTeX tasks include the .aux file in their outputs.
                    // Exclude or they will also be copied into the PDFs directory.
                    task.exclude("*.aux");
                    task.rename(src -> src.replace("_", "_" + lectureExtension.getLectureNum().get() + "_"));
                });
            });

// Generate LaTeX build tasks for each of the targets. This uses the
            // string invocation method supplied by the LaTeX plugin.
            lectureExtension.getDocTargets().get().forEach(target -> {
                latexExtension.invoke(docNames.get().get(target), (dsl) -> {
                    dsl.setExtraArguments(lectureExtension.getLatexFlags().get());
                    dsl.setWatching(docDependencies.get().get(target));
                    return null; // workaround for Kotlin Unit (void) return
                });
            });

// All generated images. Depends on any additional image generation
            // sub-tasks.
            projectTasks.register(IMAGES_TASK_NAME, task -> {
                task.setDescription("Generate images.");
                task.setGroup(LECTURE_TASK_GROUP);
                task.setDependsOn(projectTasks.withType(GenerateImageFromSourceTask.class));
            });

// Ensure that the LaTeX tasks depend on the images task. This implies
            // that *all* LaTeX documents dependent on *all* generated images,
            // even when a document doesn't actually depend on a specific image.
            // This would be too much of a hassle to fix given the relatively
            // small benefit.
            projectTasks.matching(task -> task.getName().startsWith(PDFLATEX_TASK_NAME)).forEach(pdfLatexTask -> {
                pdfLatexTask.dependsOn(projectTasks.getByName(IMAGES_TASK_NAME));
            });

// Remove files specified in cleanFiles and directories specified
            // in cleanDirs.
            projectTasks.register(CLEAN_TASK_NAME, Delete.class, task -> {
                task.setDescription("Clean up intermediate files.");
                task.setGroup(LECTURE_TASK_GROUP);

ConfigurableFileTree tree = project.fileTree(projectDirectory);
                tree.include(lectureExtension.getCleanFiles().get());
                task.delete(tree);

lectureExtension.getCleanDirs().get().forEach(
                        pattern -> task.delete(getListOfDirectories(projectDirectory, pattern))
                );
            });

// Remove everything not under version control. Unfortunately this *doesn't*
            // include the .gradle directory :(, but in hindsight that's not surprising.
            projectTasks.register(DEEP_CLEAN_TASK_NAME, Exec.class, task -> {
                task.setDescription("Remove all files not in Git.");
                task.setGroup(LECTURE_TASK_GROUP);
                task.setCommandLine("git", "clean", "-fXd");
            });

});

// Debugging information.
        projectTasks.register(DEBUG_TASK_NAME, task -> {
            task.setDescription("Print debugging information.");
            task.setGroup(LECTURE_TASK_GROUP);
            task.doLast(s -> {
                System.out.println("project name = <" + project.getName() + ">");
                System.out.println("project directory = <" + projectDirectory + ">");
                System.out.println("docTargets = <" + lectureExtension.getDocTargets().get().toString() + ">");
                System.out.println("numberedDocTargets = <" + numberedDocTargets.get().toString() + ">");
                System.out.println("docPrefix = <" + lectureExtension.getDocPrefix().get() + ">");
                System.out.println("lectureNum = <" + lectureExtension.getLectureNum().get() + ">");
                System.out.println("docNames = <" + docNames.get().toString() + ">");
                System.out.println("numberedDocNames = <" + numberedDocNames.get().toString() + ">");
                System.out.println("imageDir = <" + lectureExtension.getImageDir().get().getAsFile().getName() + ">");
                System.out.println("pdfDir = <" + lectureExtension.getPdfDir().get().getAsFile().getName() + ">");
                System.out.println("slidesImages = <" + lectureExtension.getSlidesImages().get().toString() + ">");
                System.out.println("slidesFiles = <" + lectureExtension.getSlidesFiles().get().toString() + ">");
                System.out.println("examplesImages = <" + lectureExtension.getExamplesImages().get().toString() + ">");
                System.out.println("examplesFiles = <" + lectureExtension.getExamplesFiles().get().toString() + ">");
                System.out.println("slideDependencies = <" + slideDependencies.get().toString() + ">");
                System.out.println("docDependencies = <" + docDependencies.get().toString() + ">");
                System.out.println("cleanFiles = <" + lectureExtension.getCleanFiles().get().toString() + ">");
                System.out.println("cleanDirs = <" + lectureExtension.getCleanDirs().get().toString() + ">");
                System.out.println("latexFlags = <" + lectureExtension.getLatexFlags().get().toString() + ">");
                System.out.println("latex.terminalEmulator = <" + latexExtension.getTerminalEmulator().get() + ">");
                System.out.println("latex.waitTime = <" + latexExtension.getWaitTime().get() + ">");
                System.out.println("latex.waitUnit = <" + latexExtension.getWaitUnit().get() + ">");
                System.out.println("latex.pdfLatexCommand = <" + latexExtension.getPdfLatexCommand().get() + ">");
                System.out.println("latex.bibTexCommand = <" + latexExtension.getBibTexCommand().get() + ">");
                System.out.println("latex.inkscapeCommand = <" + latexExtension.getInkscapeCommand().get() + ">");
                System.out.println("latex.gitLatexdiffCommand = <" + latexExtension.getGitLatexdiffCommand().get() + ">");
            });
        });
    }
}

package nz.stanger.lecture;

import org.danilopianini.gradle.latex.LatexExtension;

import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.file.ConfigurableFileTree;
import org.gradle.api.file.Directory;
import org.gradle.api.provider.Provider;
import org.gradle.api.provider.SetProperty;
import org.gradle.api.tasks.Copy;
import org.gradle.api.tasks.Delete;
import org.gradle.api.tasks.Exec;
import org.gradle.api.tasks.TaskContainer;

public class Lecture implements Plugin<Project> {

private static final String CONTENT = "content";
    private static final String SLIDES = "slides";
    private static final String HANDOUT = "handout";
    private static final String NOTES = "notes";
    private static final String EXAMPLES = "examples";

private static final String LECTURE_PREFIX = "lecture";

private static final String TASK_GROUP = "Lecture";

private static final Set<String> VALID_TARGET_NAMES = Set.of(
            SLIDES,
            HANDOUT,
            NOTES,
            EXAMPLES
    );

// Some handy references that are used a lot.
    private TaskContainer projectTasks;
    private Directory projectDirectory;
    private LectureExtension lecture;
    private LatexExtension latex;

/**
     * Find directories whose names match a regular expression.
     *
     * Adapted from https://gist.github.com/Ethsaam/2b8dd748fcc25e6973bb.
     *
     * @param dir the directory to start the search in
     * @param pattern regular expression matching directory names
     * @return the collection of matching directories
     */
    private Collection<File> getListOfDirectories(Directory dir, String pattern) {
        return new ArrayList<>(Arrays.asList(dir.getAsFile().listFiles(file -> file.isDirectory() && file.getName().matches(pattern))));
    }

/**
     * Register a task to generate an image from some other format.
     *
     * @param srcRegex regular expression matching source files (inputs)
     * @param dstRegex regular expression matching destination files (outputs)
     * @param cmdTemplate list of command line components (strings)
     */
    private void registerGeneratedImageTask(String srcRegex, String dstRegex, List<String> cmdTemplate) {
        lecture.getGeneratedImages().get().entrySet().stream()
                .filter(entry -> entry.getValue().matches(srcRegex))
                .filter(entry -> entry.getKey().matches(dstRegex))
                .forEach(entry -> {
                    File dst = lecture.getImageDir().file(entry.getKey()).get().getAsFile();
                    File src = lecture.getImageDir().file(entry.getValue()).get().getAsFile();
                    projectTasks.register("images." + entry.getKey(), Exec.class, task -> {
                        task.setDescription("Generate " + entry.getKey() + " from " + entry.getValue() + ".");
                        task.setGroup(TASK_GROUP);
                        File cropped = lecture.getImageDir().file(entry.getKey().replace(".pdf", "-crop.pdf")).get().getAsFile();

// set working directory to imageDir so that relative
                        // references work, e.g., PlantUML includes
                        task.setWorkingDir(lecture.getImageDir().get());
                        task.getInputs().files(src);
                        task.getOutputs().files(dst);

List<String> command = cmdTemplate.stream().map(
                                part -> part.replaceAll("<<src>>", src.getName())
                                        .replaceAll("<<dst>>", dst.getName())
                                        .replaceAll("<<cropped>>", cropped.getName())
                        ).collect(Collectors.toList());
                        task.commandLine(command);
                    });
                    // Every PDF generation will have a different hash, so only run the
                    // task if the input is newer than the output.
                    projectTasks.getByPath("images." + entry.getKey()).onlyIf(t -> {
                        return src.lastModified() > dst.lastModified();
                    });
                });
    }

@Override
    public void apply(Project project) {
        projectTasks = project.getTasks();
        projectDirectory = project.getLayout().getProjectDirectory();

project.getPluginManager().apply("org.danilopianini.gradle-latex");

// Plugin extensions.
        lecture = project.getExtensions().create("lecture", LectureExtension.class);
        latex = project.getExtensions().getByType(LatexExtension.class);

// Configure LaTeX extension.
        latex.getPdfLatexCommand().set("xelatex");

/**
         * Set plugin defaults.
         */
        // Supported document targets.
        lecture.getDocTargets().convention(VALID_TARGET_NAMES);

// Validate document target configuration. Must be afterEvaluate() to
        // ensure everything has been finalised.
        project.afterEvaluate(p -> {
            lecture.getDocTargets().get().stream().forEach(target -> {
                if (!VALID_TARGET_NAMES.contains(target)) {
                    throw new RuntimeException("unsupported target name " + target);
                }
            });
        });

// Supported targets (numbered documents). Automatically derived from
        // LectureExtension.docTargets.
        Provider<Set<String>> numberedDocTargets = lecture.getDocTargets().map(
                docTargets -> docTargets.stream().map(target -> target + ".numbered").collect(Collectors.toSet())
        );

// Standard lecture prefix string.
        lecture.getDocPrefix().convention(LECTURE_PREFIX);

lecture.getLectureNum().convention(project.getName().substring(0, 2));

// Standard document names (unnumbered). Automatically derived from
        // LectureExtension.docTargets, plus "content".
        Provider<Map<String, String>> docNames = lecture.getDocTargets().map(docTargets -> {
            Map<String, String> names = new HashMap<>();
            docTargets.forEach(target -> names.put(target, lecture.getDocPrefix().get() + "_" + target));
            names.put(CONTENT, lecture.getDocPrefix().get() + "_" + CONTENT);
            return names;
        });

// Standard document names (numbered). Automatically derived from
        // LectureExtension.docTargets, plus "content".
        Provider<Map<String, String>> numberedDocNames = lecture.getDocTargets().map(docTargets -> {
            Map<String, String> names = new HashMap<>();
            docTargets.forEach(target -> names.put(target, lecture.getDocPrefix().get() + "_" + lecture.getLectureNum().get() + "_" + target));
            names.put(CONTENT, lecture.getDocPrefix().get() + "_" + lecture.getLectureNum().get() + "_" + CONTENT);
            return names;
        });

lecture.getImageDir().convention(projectDirectory.dir("images"));

lecture.getPdfDir().convention(projectDirectory.dir("pdfs"));

// slidesImages defaults to empty
        lecture.getSlidesFiles().convention(
                lecture.getDocPrefix().map(
                        (String prefix) -> Set.of(
                                prefix + "_" + CONTENT + ".tex",
                                "paper_init.tex",
                                "lecturedates.tex",
                                "doc_init.tex"
                        )
                )
        );

// examplesImages defaults to empty
        lecture.getExamplesFiles().convention(
                lecture.getDocPrefix().map((String prefix) -> {
                    if (lecture.getDocTargets().get().contains(EXAMPLES)) {
                        return Set.of(
                                prefix + "_" + EXAMPLES + ".tex",
                                "paper_init.tex",
                                "lecturedates.tex",
                                "doc_init.tex"
                        );
                    } else {
                        return Set.of();
                    }
                })
        );

// Document dependencies. Automatically derived from slidesImages,
        // slidesFiles, examplesImages, and examplesFiles. Images are mapped to
        // imageDir. The slides, handout, and notes will always share the same
        // dependencies. Only the examples will be different.
        Provider<Set<String>> slideDependencies = lecture.getSlidesImages().map(slideImages -> {
            Set<String> slideDeps = new HashSet<>();
            slideDeps.addAll(slideImages.stream().map(image -> lecture.getImageDir().get() + "/" + image).collect(Collectors.toSet()));
            slideDeps.addAll(lecture.getSlidesFiles().get());
            return slideDeps;
        });

Provider<Map<String, List<String>>> docDependencies = lecture.getDocTargets().map(docTargets -> {
            Map<String, List<String>> docDeps = new HashMap<>();
            docTargets.forEach(target -> {
                if (target.equals("examples")) {
                    List<String> deps = lecture.getExamplesFiles().get().stream().collect(Collectors.toList());
                    deps.addAll(lecture.getExamplesImages().get().stream()
                            .map(image -> lecture.getImageDir().get() + "/" + image)
                            .collect(Collectors.toList())
                    );
                    docDeps.put(target, deps);
                } else {
                    docDeps.put(target, slideDependencies.get().stream().collect(Collectors.toList()));
                }
            });
            return docDeps;
        });

// generatedImages defaults to empty
        lecture.getCleanFiles().convention(Set.of(
                "*.aux",
                "*.dvi",
                "*.fdb_latexmk",
                "*.fls",
                "*.head",
                "*.listing",
                "*.log",
                "*.nav",
                "*.out",
                "*.pyg",
                "*.snm",
                "*.synctex.gz",
                "*.tmp",
                "*.toc",
                "*.vrb",
                "*.xdv"
        ));
        // These are regular expressions, NOT glob patterns.
        lecture.getCleanDirs().convention(Set.of(
                "_minted.*"
        ));

lecture.getLatexFlags().convention(Set.of(
                "-shell-escape",
                "-synctex=1",
                "-interaction=nonstopmode",
                "-halt-on-error",
                "-file-line-error"
        ));

project.setDefaultTasks(Arrays.asList("docs", "numbered"));

// All unnumbered documents.
            projectTasks.register("docs", task -> {
                task.setDescription("Build all documents.");
                task.setGroup(TASK_GROUP);
                task.dependsOn(lecture.getDocTargets());
            });

// Generate tasks for each of the unnumbered document targets.
            // All generated tasks that derive from configuration variables must be
            // afterEvaluate() to ensure everything has been finalised.
            lecture.getDocTargets().get().forEach(target -> {
                projectTasks.register(target, task -> {
                    task.setDescription("Build " + target + " document.");
                    task.setGroup(TASK_GROUP);
                    task.dependsOn("pdfLatex." + docNames.get().get(target));
                });
            });

// All numbered documents.
            projectTasks.register("numbered", task -> {
                task.setDescription("Create numbered versions of all documents.");
                task.setGroup(TASK_GROUP);
                task.dependsOn(numberedDocTargets);
            });

// Generate tasks for each of the numbered document targets.
            numberedDocTargets.get().forEach(target -> {
                projectTasks.register(target, Copy.class, task -> {
                    String baseTarget = target.replace(".numbered", "");
                    task.setDescription("Build numbered version of " + baseTarget + " document.");
                    task.setGroup(TASK_GROUP);

task.from(project.getTasksByName("pdfLatex." + docNames.get().get(baseTarget), true));
                    task.into(lecture.getPdfDir());

// The LaTeX tasks include the .aux file in their outputs.
                    // Exclude or they will also be copied into the PDFs directory.
                    task.exclude("*.aux");
                    task.rename(src -> src.replace("_", "_" + lecture.getLectureNum().get() + "_"));
                });
            });

// Generate LaTeX build tasks for each of the targets. This uses the
            // string invocation method supplied by the LaTeX plugin.
            lecture.getDocTargets().get().forEach(target -> {
                latex.invoke(docNames.get().get(target), (dsl) -> {
                    dsl.setExtraArguments(lecture.getLatexFlags().get());
                    dsl.setWatching(docDependencies.get().get(target));
                    return null; // workaround for Kotlin Unit (void) return
                });
            });

// Add image task dependencies to the generated LaTeX tasks.
            // No need to check whether there are any generated images, Gradle does
            // the right thing if the list is empty. This also makes *all* LaTeX
            // documents dependent on *all* generated images, even when a document
            // doesn't actually depend on a specific image. This would be too much
            // of a hassle to fix given the relatively small benefit.
            projectTasks.matching(task -> task.getName().startsWith("pdfLatex")).forEach(pdfLatexTask -> {
                pdfLatexTask.dependsOn(projectTasks.matching(t -> t.getName().startsWith("images.")));
            });

// All generated images.
            projectTasks.register("images", task -> {
                task.setDescription("Generate images.");
                task.setGroup(TASK_GROUP);
                task.setDependsOn(projectTasks.matching(t -> t.getName().startsWith("images.")));
            });

// Remove files specified in cleanFiles and directories specified
            // in cleanDirs.
            //!! Does this need afterEvaluate()?
            projectTasks.register("clean", Delete.class, task -> {
                task.setDescription("Clean up intermediate files.");
                task.setGroup(TASK_GROUP);

ConfigurableFileTree tree = project.fileTree(projectDirectory);
                tree.include(lecture.getCleanFiles().get());
                task.delete(tree);

lecture.getCleanDirs().get().forEach(
                        pattern -> task.delete(getListOfDirectories(projectDirectory, pattern))
                );
            });

// Remove everything not under version control. Unfortunately this *doesn't*
            // include the .gradle directory :(, but in hindsight that's not surprising.
            projectTasks.register("deepClean", Exec.class, task -> {
                task.setDescription("Remove all files not in Git.");
                task.setGroup(TASK_GROUP);
                task.setCommandLine("git", "clean", "-fXd");
            });

/**
             * Per-file tasks to convert images.
             *
             * By default these assume single-file inputs, e.g., foo.svg ->
             * foo.pdf. If you have a file that is dependent on multiple inputs
             * (e.g., bar.pu -> foo.pu -> foo.pdf), register an independent task
             * in the lecture's build.gradle.kts by copying the corresponding
             * registration code below, substituting the actual filenames in
             * place of the variable references like key and
             * generatedImages[key]. Also remove the file from generatedImages
             * to avoid a name clash. You can access properties like imageDir
             * via project.properties (these will probably need explicit type
             * casting).
             */
            // Generate per-file tasks to convert PlantUML to PDF.
            registerGeneratedImageTask(
                    ".*\\.(pu|puml|plantuml)$",
                    ".*\\.pdf$",
                    // Direct PDF from PlantUML is problematic, go via SVG instead.
                    new ArrayList<>(Arrays.asList(
                            "bash", "-c",
                            "plantuml -tsvg -pipe < <<src>> | rsvg-convert --format pdf > <<dst>> && pdfcrop <<dst>> <<cropped>> && mv -f <<cropped>> <<dst>>"
                    ))
            );

// Generate per-file tasks to convert SVG to PDF.
            registerGeneratedImageTask(
                    ".*\\.svg$",
                    ".*\\.pdf$",
                    new ArrayList<>(Arrays.asList(
                            "bash", "-c",
                            "rsvg-convert --format pdf <<src>> > <<dst>> && pdfcrop <<dst>> <<cropped>> && mv -f <<cropped>> <<dst>>"
                    ))
            );

// Generate per-file tasks to convert R to PDF.
            registerGeneratedImageTask(
                    ".*\\.R$",
                    ".*\\.pdf$",
                    new ArrayList<>(Arrays.asList(
                            "bash", "-c",
                            "R --no-echo --file=<<src>> --args <<dst>> && pdfcrop <<dst>> <<cropped>> && mv -f <<cropped>> <<dst>>"
                    ))
            );
        });

// Debugging information.
        projectTasks.register("debug", task -> {
            task.setDescription("Print debugging information.");
            task.setGroup(TASK_GROUP);
            task.doLast(s -> {
                System.out.println("project name = <" + project.getName() + ">");
                System.out.println("project directory = <" + projectDirectory + ">");
                System.out.println("docTargets = <" + lecture.getDocTargets().get().toString() + ">");
                System.out.println("numberedDocTargets = <" + numberedDocTargets.get().toString() + ">");
                System.out.println("docPrefix = <" + lecture.getDocPrefix().get() + ">");
                System.out.println("lectureNum = <" + lecture.getLectureNum().get() + ">");
                System.out.println("docNames = <" + docNames.get().toString() + ">");
                System.out.println("numberedDocNames = <" + numberedDocNames.get().toString() + ">");
                System.out.println("imageDir = <" + lecture.getImageDir().get().getAsFile().getName() + ">");
                System.out.println("pdfDir = <" + lecture.getPdfDir().get().getAsFile().getName() + ">");
                System.out.println("slidesImages = <" + lecture.getSlidesImages().get().toString() + ">");
                System.out.println("slidesFiles = <" + lecture.getSlidesFiles().get().toString() + ">");
                System.out.println("examplesImages = <" + lecture.getExamplesImages().get().toString() + ">");
                System.out.println("examplesFiles = <" + lecture.getExamplesFiles().get().toString() + ">");
                System.out.println("slideDependencies = <" + slideDependencies.get().toString() + ">");
                System.out.println("docDependencies = <" + docDependencies.get().toString() + ">");
                System.out.println("generatedImages = <" + lecture.getGeneratedImages().get().toString() + ">");
                System.out.println("cleanFiles = <" + lecture.getCleanFiles().get().toString() + ">");
                System.out.println("cleanDirs = <" + lecture.getCleanDirs().get().toString() + ">");
                System.out.println("latexFlags = <" + lecture.getLatexFlags().get().toString() + ">");
                System.out.println("latex.terminalEmulator = <" + latex.getTerminalEmulator().get() + ">");
                System.out.println("latex.waitTime = <" + latex.getWaitTime().get() + ">");
                System.out.println("latex.waitUnit = <" + latex.getWaitUnit().get() + ">");
                System.out.println("latex.pdfLatexCommand = <" + latex.getPdfLatexCommand().get() + ">");
                System.out.println("latex.bibTexCommand = <" + latex.getBibTexCommand().get() + ">");
                System.out.println("latex.inkscapeCommand = <" + latex.getInkscapeCommand().get() + ">");
                System.out.println("latex.gitLatexdiffCommand = <" + latex.getGitLatexdiffCommand().get() + ">");
            });
        });
    }
}

Ignore Space Show notes View buildSrc/src/main/java/nz/stanger/lecture/LectureExtension.java
package nz.stanger.lecture; import org.gradle.api.provider.Property; import org.gradle.api.provider.SetProperty; import org.gradle.api.file.DirectoryProperty; /** * Extension to the lecture plugin with additional properties. / abstract public class LectureExtension { /* * Supported targets (unnumbered documents). * * These are configurable, but only within a list of valid target names, so * you can disable supported targets but not create new ones. * * Remove any targets that don't exist for this lecture. New targets must be * registered in the lecture's {@code build.gradle}. The target list for * numbered documents is automatically derived from this. * * @return the configured set of targets * @see nz.stanger.lecture.Lecture / abstract public SetProperty<String> getDocTargets(); /* * Standard prefix for lecture documents. * * Document files are named as {@code prefix_type.tex}, e.g., * {@code lecture_slides.tex}. * * @return the configured lecture document prefix / abstract public Property<String> getDocPrefix(); /* * Lecture number. * * Default is to derive from the project name (assumes the project folder is * named something like {@code 01_Lecture_Title}). This is inserted into the * file names of numbered outputs (e.g., {@code lecture_01_slides.pdf}. * * @return the configured lecture number (0 prefixed if necessary) / abstract public Property<String> getLectureNum(); /* * Subdirectory in which images are kept. * * @return the configured images directory / abstract public DirectoryProperty getImageDir(); /* * Subdirectory to which numbered PDFs will be written. * * Originally these were written into the project directory, but it * completely confused Gradle into thinking that all the input files in the * project had been touched and it yelled about implicit task dependencies. * See * {@link https://docs.gradle.org/7.3.1/userguide/validation_problems.html#implicit_dependency}. * * @return the configured PDFs directory / abstract public DirectoryProperty getPdfDir(); /* * Images used by the slides, handout, and notes documents. * * These will become dependencies of the document. Images will be * automatically mapped to {@code imageDir}. * * @return the configured set of images * @see #getImageDir() / abstract public SetProperty<String> getSlidesImages(); /* * Files used by the slides, handout, and notes documents. * * These will become dependencies of the document. * * @return the configured set of files / abstract public SetProperty<String> getSlidesFiles(); /* * Images used by the examples document. * * These will become dependencies of the document. Images will be * automatically mapped to {@code imageDir}. * * @return the configured set of images * @see #getImageDir() / abstract public SetProperty<String> getExamplesImages(); /* * Images and files used by the examples document. * * These will become dependencies of the document. * * @return the configured set of files / abstract public SetProperty<String> getExamplesFiles(); /* * Files to be removed by the clean task. * * @return the configured set of files to remove / abstract public SetProperty<String> getCleanFiles(); /* * Directories to be removed by the clean task. * * Directories are handled separately because {@code FileTree} really only * stores files :(. * * @return the configured set of directories to remove / abstract public SetProperty<String> getCleanDirs(); /* * Command line options for LaTeX. * * This is a set, so duplicates will be automatically eliminated. * * @return the configured LaTeX command line options / abstract public SetProperty<String> getLatexFlags(); } package nz.stanger.lecture; import org.gradle.api.provider.Property; import org.gradle.api.provider.MapProperty; import org.gradle.api.provider.SetProperty; import org.gradle.api.file.DirectoryProperty; abstract public class LectureExtension { /* * Supported targets (unnumbered documents). * * These are configurable, but only within a list of valid target names * i.e., you can disable supported targets but not create new ones. * * Remove any targets that don't exist for this lecture. New targets must be * registered in the lecture's build.gradle.kts. The target list for * numbered documents is automatically derived from this (see Lecture.java). * * @return the configured set of targets / abstract public SetProperty<String> getDocTargets(); /* * Standard prefix for lecture documents. * * Document files are named as "prefix_type.tex", e.g., * "lecture_slides.tex". * * @return the configured lecture document prefix / abstract public Property<String> getDocPrefix(); /* * Lecture number. * * Default is to derive from the project name (assumes the project folder is * named something like "01_Lecture_Title"). This is inserted into the file * names of numbered outputs (e.g., "lecture_01_slides.pdf". * * @return the configured lecture number (0 prefixed if necessary) / abstract public Property<String> getLectureNum(); /* * Subdirectory in which images are kept. * * @return the configured images directory / abstract public DirectoryProperty getImageDir(); /* * Subdirectory to which numbered PDFs will be written. * * Originally these were written into the project directory, but it seemed * to completely confuse Gradle into thinking that all the input files in * the project had been touched and it yelled about implicit task * dependencies. See * https://docs.gradle.org/7.3.1/userguide/validation_problems.html#implicit_dependency. * * @return the configured PDFs directory / abstract public DirectoryProperty getPdfDir(); /* * Images used by the slides, handout, and notes documents. * * These will become dependencies of the document. Images will be * automatically mapped to imageDir (above). * * @return the configured set of images / abstract public SetProperty<String> getSlidesImages(); /* * Files used by the slides, handout, and notes documents. * * These will become dependencies of the document. * * @return the configured set of files / abstract public SetProperty<String> getSlidesFiles(); /* * Images used by the examples document. * * These will become dependencies of the document. Images will be * automatically mapped to imageDir (above). * * @return the configured set of images / abstract public SetProperty<String> getExamplesImages(); /* * Images and files used by the examples document. * * These will become dependencies of the document. * * @return the configured set of files / abstract public SetProperty<String> getExamplesFiles(); /* * Images that are generated from another format. * * The key is the target image, the value is the source image. This is * independent of the slidesImages and examplesImages (above). All images * will be mapped to imageDir (above). * * @return MapProperty<String> / abstract public MapProperty<String, String> getGeneratedImages(); /* * Files to be removed by the clean task. * * @return the configured set of files to remove / abstract public SetProperty<String> getCleanFiles(); /* * Directories to be removed by the clean task. * * Directories are separate because FileTree only stores files :(. * * @return the configured set of directories to remove / abstract public SetProperty<String> getCleanDirs(); /* * Command line options for LaTeX. * * This is a set, so duplicates will be automatically eliminated. * * @return the configured LaTeX command line options */ abstract public SetProperty<String> getLatexFlags(); }

Ignore Space Show notes View

buildSrc/src/main/java/nz/stanger/lecture/LectureExtension.java

package nz.stanger.lecture;

import org.gradle.api.provider.Property;
import org.gradle.api.provider.SetProperty;
import org.gradle.api.file.DirectoryProperty;

/**
 * Extension to the lecture plugin with additional properties.
 */
abstract public class LectureExtension {

/**
     * Supported targets (unnumbered documents).
     *
     * These are configurable, but only within a list of valid target names, so
     * you can disable supported targets but not create new ones.
     *
     * Remove any targets that don't exist for this lecture. New targets must be
     * registered in the lecture's {@code build.gradle}. The target list for
     * numbered documents is automatically derived from this.
     *
     * @return the configured set of targets
     * @see nz.stanger.lecture.Lecture
     */
    abstract public SetProperty<String> getDocTargets();

/**
     * Standard prefix for lecture documents.
     *
     * Document files are named as {@code prefix_type.tex}, e.g.,
     * {@code lecture_slides.tex}.
     *
     * @return the configured lecture document prefix
     */
    abstract public Property<String> getDocPrefix();

/**
     * Lecture number.
     *
     * Default is to derive from the project name (assumes the project folder is
     * named something like {@code 01_Lecture_Title}). This is inserted into the
     * file names of numbered outputs (e.g., {@code lecture_01_slides.pdf}.
     *
     * @return the configured lecture number (0 prefixed if necessary)
     */
    abstract public Property<String> getLectureNum();

/**
     * Subdirectory in which images are kept.
     *
     * @return the configured images directory
     */
    abstract public DirectoryProperty getImageDir();

/**
     * Subdirectory to which numbered PDFs will be written.
     *
     * Originally these were written into the project directory, but it
     * completely confused Gradle into thinking that all the input files in the
     * project had been touched and it yelled about implicit task dependencies.
     * See
     * {@link https://docs.gradle.org/7.3.1/userguide/validation_problems.html#implicit_dependency}.
     *
     * @return the configured PDFs directory
     */
    abstract public DirectoryProperty getPdfDir();

/**
     * Images used by the slides, handout, and notes documents.
     *
     * These will become dependencies of the document. Images will be
     * automatically mapped to {@code imageDir}.
     *
     * @return the configured set of images
     * @see #getImageDir()
     */
    abstract public SetProperty<String> getSlidesImages();

/**
     * Files used by the slides, handout, and notes documents.
     *
     * These will become dependencies of the document.
     *
     * @return the configured set of files
     */
    abstract public SetProperty<String> getSlidesFiles();

/**
     * Images used by the examples document.
     *
     * These will become dependencies of the document. Images will be
     * automatically mapped to {@code imageDir}.
     *
     * @return the configured set of images
     * @see #getImageDir()
     */
    abstract public SetProperty<String> getExamplesImages();

/**
     * Images and files used by the examples document.
     *
     * These will become dependencies of the document.
     *
     * @return the configured set of files
     */
    abstract public SetProperty<String> getExamplesFiles();

/**
     * Files to be removed by the clean task.
     *
     * @return the configured set of files to remove
     */
    abstract public SetProperty<String> getCleanFiles();

/**
     * Directories to be removed by the clean task.
     *
     * Directories are handled separately because {@code FileTree} really only
     * stores files :(.
     *
     * @return the configured set of directories to remove
     */
    abstract public SetProperty<String> getCleanDirs();

/**
     * Command line options for LaTeX.
     *
     * This is a set, so duplicates will be automatically eliminated.
     *
     * @return the configured LaTeX command line options
     */
    abstract public SetProperty<String> getLatexFlags();

}

package nz.stanger.lecture;

import org.gradle.api.provider.Property;
import org.gradle.api.provider.MapProperty;
import org.gradle.api.provider.SetProperty;
import org.gradle.api.file.DirectoryProperty;

abstract public class LectureExtension {

/**
     * Supported targets (unnumbered documents).
     *
     * These are configurable, but only within a list of valid target names
     * i.e., you can disable supported targets but not create new ones.
     *
     * Remove any targets that don't exist for this lecture. New targets must be
     * registered in the lecture's build.gradle.kts. The target list for
     * numbered documents is automatically derived from this (see Lecture.java).
     *
     * @return the configured set of targets
     */
    abstract public SetProperty<String> getDocTargets();

/**
     * Standard prefix for lecture documents.
     *
     * Document files are named as "prefix_type.tex", e.g.,
     * "lecture_slides.tex".
     *
     * @return the configured lecture document prefix
     */
    abstract public Property<String> getDocPrefix();

/**
     * Lecture number.
     *
     * Default is to derive from the project name (assumes the project folder is
     * named something like "01_Lecture_Title"). This is inserted into the file
     * names of numbered outputs (e.g., "lecture_01_slides.pdf".
     *
     * @return the configured lecture number (0 prefixed if necessary)
     */
    abstract public Property<String> getLectureNum();

/**
     * Subdirectory in which images are kept.
     *
     * @return the configured images directory
     */
    abstract public DirectoryProperty getImageDir();

/**
     * Subdirectory to which numbered PDFs will be written.
     *
     * Originally these were written into the project directory, but it seemed
     * to completely confuse Gradle into thinking that all the input files in
     * the project had been touched and it yelled about implicit task
     * dependencies. See
     * https://docs.gradle.org/7.3.1/userguide/validation_problems.html#implicit_dependency.
     *
     * @return the configured PDFs directory
     */
    abstract public DirectoryProperty getPdfDir();

/**
     * Images used by the slides, handout, and notes documents.
     *
     * These will become dependencies of the document. Images will be
     * automatically mapped to imageDir (above).
     *
     * @return the configured set of images
     */
    abstract public SetProperty<String> getSlidesImages();

/**
     * Images used by the examples document.
     *
     * These will become dependencies of the document. Images will be
     * automatically mapped to imageDir (above).
     *
     * @return the configured set of images
     */
    abstract public SetProperty<String> getExamplesImages();

/**
     * Images that are generated from another format.
     *
     * The key is the target image, the value is the source image. This is
     * independent of the slidesImages and examplesImages (above). All images
     * will be mapped to imageDir (above).
     *
     * @return MapProperty<String>
     */
    abstract public MapProperty<String, String> getGeneratedImages();

/**
     * Files to be removed by the clean task.
     *
     * @return the configured set of files to remove
     */
    abstract public SetProperty<String> getCleanFiles();

/**
     * Directories to be removed by the clean task.
     *
     * Directories are separate because FileTree only stores files :(.
     *
     * @return the configured set of directories to remove
     */
    abstract public SetProperty<String> getCleanDirs();

}

Ignore Space Show notes View buildSrc/src/main/java/nz/stanger/resources/fopconfig.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?> <fop version="1.0"> <fonts> <auto-detect/> </fonts> </fop>

Ignore Space Show notes View gradle.properties 0 → 100644
systemProp.java.awt.headless=true

Show line notes below