pric

#!/usr/bin/env groovy
/* Copyright 2020 Hernán José Cervera Manzanilla
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

@Grab(group='org.asciidoctor', module='asciidoctorj', version='2.4.0')
@Grab(group='org.asciidoctor', module='asciidoctorj-pdf', version='1.5.3')
@Grab(group='info.picocli', module='picocli', version='4.4.0')

import picocli.CommandLine
import picocli.CommandLine.Command
import picocli.CommandLine.Option
import picocli.CommandLine.Parameters
import picocli.CommandLine.ArgGroup

import java.util.regex.Pattern

import org.asciidoctor.*
import org.asciidoctor.extension.*

import static org.asciidoctor.Asciidoctor.Factory.create
import static org.asciidoctor.AttributesBuilder.attributes
import static org.asciidoctor.OptionsBuilder.options

@Command(name = 'pric',
        version = 'pric 1.1.1',
        mixinStandardHelpOptions = true,
        headerHeading = '%n',
        header = 'Print multiple source code files to a single PDF file.',
        synopsisHeading = '%n',
        abbreviateSynopsis = true,
        parameterListHeading = '%nParameters:%n',
        optionListHeading = '%nOptions:%n',
        exitCodeListHeading = '%nExit codes:%n',
        exitCodeList = [
                '0: Successful PDF generation.',
                '1: No PDF was generated.'
        ],

        // Pric example uses
        footerHeading = '%nExamples:%n',
        footer = """\
Notice that the default title of every document is the provided filename
(in the examples below, the title of most documents is 'out'). To set an
appropriate title different from the filename, use the option -t, as shown
in the example 3.

1. Include all Java and XML files on the current dir and its sub-dirs.
@|yellow pric out.pdf -r -e java,xml|@

2. Include all Markdown files and the LICENSE file found on the current directory.
@|yellow pric out.pdf -e md -f 'LICENSE'|@
Notice the single quotes around LICENSE. Always use single quotes around the
arg value of -f, to avoid the shell from evaluating the expression.

3. Include all SQL files in current dir and add cover page with title and author.
@|yellow pric out.pdf -e sql -a 'Hernan Cervera' -t 'Database design'|@

4. Include all SQL files in current dir and remove cover page from PDF.
@|yellow pric out.pdf -e sql -c|@ 
""")
class Pric implements Runnable {
    @ArgGroup(exclusive = false, multiplicity = '1')
    FilesFilter filesFilter
    @Parameters(index = '0', paramLabel = 'file',
            description = "Filename of the PDF, must end in '.pdf'.")
    String outputFilename
    @Option(names = ['-t', '--title'],
            description = 'Title of the document. If omitted, filename is used.')
    String title
    @Option(names = ['-a', '--author'],
            description = 'Author of the document.')
    String author
    @Option(names = ['-p', '--paths'], paramLabel = '<path>', split = '[?]', splitSynopsisLabel = '?',
            description = 'Absolute or relative paths to directories to search for files (default is current dir)')
    List<String> paths = ['.']
    @Option(names = ['-r', '--recursive'],
            description = 'Recurse sub-directories.')
    boolean recursive
    @Option(names = ['-k', '--keep-asciidoc'],
            description = 'Preserve AsciiDoc file after PDF generation.')
    boolean keepAsciidoc
    @Option(names = ['-s', '--silent'],
            description = 'Do not show log messages.')
    boolean loggerSilent
    @Option(names = ['-c', '--compact'], description = 'Produce a PDF with more code per page and no cover page.')
    boolean compact

    static class FilesFilter {
        @Option(names = ['-e', '--extensions'], split = ',', paramLabel = '<ext>',
                description = 'Extensions of the files to be printed.')
        List<String> extensions
        @Option(names = ['-f', '--files'], split = ':', paramLabel = '<regex>',
                description = 'Match filenames by regex.')
        List<Pattern> patterns
    }

    def ext2type = [
            // Backend
            java: 'java',
            groovy: 'groovy',
            php: 'php',
            py: 'python',
            rb: 'ruby',
            clj: 'clojure',
            go: 'go',
            lua: 'lua',
            // Frontend
            js: 'javascript',
            html: 'html',
            css: 'css',
            cljs: 'clojure',
            // Markup
            xml: 'xml',
            json: 'json',
            yml: 'yaml',
            yaml: 'yaml',
            // Query
            sql: 'sql',
            // Low level
            c: 'c',
            cpp: 'c++'
    ]

    private List<Closure<Boolean>> matchStrategies() {
        List<Closure<Boolean>> strategies = new ArrayList<>();

        if (filesFilter.extensions) {
            Closure<Boolean> strategy = { filename, fileExtension -> fileExtension in filesFilter.extensions }
            strategies.add(strategy)
        }
        if (filesFilter.patterns) {
            Closure<Boolean> strategy = {
                filename, fileExtension -> {
                    boolean matches = false
                    for (def pattern : filesFilter.patterns) {
                        if ((filename =~ pattern).matches()) {
                            matches = true
                            break
                        }
                    }
                    return matches
                }
            }
            strategies.add(strategy)
        }

        return strategies
    }

    @Override
    void run() {
        // Configure PDF printer
        PricPDFPrinter printer = new PricPDFPrinter(
                pric: this,
                logger: new Logger(silent: loggerSilent),
                matchStrategies: matchStrategies())
        printer.print() // Generate files
    }

    static void main (String... args) {
        new CommandLine(new Pric()).execute(args)
        System.exit(0)
    }
}

class PricPDFPrinter {
    // Options and parameters bindings
    Pric pric
    // Logger
    Logger logger
    // Filename match strategies
    List<Closure<Boolean>> matchStrategies

    void print() {
        // Check the file passed by -o has .pdf extension
        if (!pric.outputFilename.endsWith('.pdf')) {
            logger.error('File name supplied by -o is not a PDF file. ' +
                    'Verify the filename has extension \'.pdf\'.')
            System.exit(1)
        }
        // If it has .pdf extension, generate the PDF file
        File adocFile = buildAdocFile()
        generatePDF(adocFile)

        // Conditional cleanup
        if (!pric.keepAsciidoc) {
            adocFile.delete()
        }
    }

    private void generatePDF(File adocFile) {
        Asciidoctor asciidoctor = create()

        Attributes attributes = attributes().sourceHighlighter('coderay').get()
        Options options = options().inPlace(true).safe(SafeMode.UNSAFE).backend('pdf')
                .attributes(attributes).get()

        logger.info("Generating PDF: ${adocFile.absolutePath.replaceAll('[.]adoc', '.pdf')}")

        asciidoctor.convertFile(adocFile, options)

        logger.info('Successful PDF generation.')
    }

    private File buildAdocFile() {
        // Filename without extension
        String filePathNoExtension = pric.outputFilename.replaceAll(/[.]\w+/, '')
        String basename = (filePathNoExtension =~ /[\w\d!,\s;()$%&#¿'{}\[\]~_`+-]+$/).findAll()[0]

        // Create AsciiDoc file
        File adocFile = new File("${filePathNoExtension}.adoc")

        // Set file title, author and doctype
        StringBuilder header = new StringBuilder("= ${pric.title ?: basename}\n")
        if (pric.author) { header.append(":author: $pric.author").append('\n') }
        header.append(':source-highlighter: coderay').append('\n')
        if (!pric.compact) { header.append(':doctype: book').append('\n') }
        else if (pric.author) { header.append('\n[.text-center]\n{author}\n') }

        try {
            adocFile.withWriter('utf-8') { writer ->
                writer.write(header.toString())
            }
        } catch (FileNotFoundException e) {
            logger.error("A directory in the supplied path $pric.outputFilename does not exist.")
            System.exit(1)
        }

        // Add include directives
        includeFilesInAdoc(pric.recursive, pric.paths, adocFile)
        return adocFile
    }

    private void includeFilesInAdoc(boolean recursive, List<String> paths, File adocFile) {
        if (includeFilesInAdocHelper(recursive, paths, adocFile, 0) == 0) {
            logger.info('No files were found. Check the values of -e and -p (if supplied).')
            adocFile.delete()
            System.exit(1)
        }
    }

    private int includeFilesInAdocHelper(boolean recursive, List<String> paths, File adocFile, int matched) {
        for (String path : paths) {
            File dir = new File(path)
            // Skip non-existent path
            if (!dir.exists()) {
                logger.warn("Non existent path, skipping: $dir.absolutePath")
                continue
            }
            // Skip if is not directory
            if (!dir.isDirectory()) {
                logger.warn("Path is not a directory, skipping: $dir.absolutePath")
                continue
            }

            // Iterate files and build adoc file
            dir.eachFile { file ->
                if (file.isDirectory() && !file.name.startsWith('.') && recursive) {
                    matched = includeFilesInAdocHelper(recursive, [file.path], adocFile, matched)
                }
                if (!file.isDirectory()) {
                    def partedFilename = file.name.split('[.]')
                    String fileExtension = partedFilename.size() > 1 ? partedFilename[1] : ''

                    for (Closure<Boolean> strategy : matchStrategies) {
                        if (strategy.call(file.name, fileExtension)) {
                            logger.info("Adding to output: $file.absolutePath")

                            matched++
                            adocFile.withWriterAppend('utf-8') { writer ->
                                writer.writeLine("""
                            ${ pric.compact ? ".$file.name" : "== [small]#$file.name#"}
                            [%autofit]
                            [source,${pric.ext2type[fileExtension] ?: 'text'}]
                            ----
                            include::$file.absolutePath[]
                            ----""".stripIndent())
                            }
                            break
                        }
                    }
                }
            }
        }

        return matched
    }
}

// Helper logger class
class Logger {
    boolean silent = false
    final static String INFO = 'INFO'
    final static String WARNING = 'WARNING'
    final static String ERROR = 'ERROR'

    private static String noticeTemplate(String notice) { "[$notice]" }

    private void log(String notice, String msg, PrintStream stream) {
        if (!silent) stream.println("${noticeTemplate(notice)} $msg")
    }

    void info(String msg) {
        log(INFO, msg, System.out)
    }
    void warn(String msg) {
        log(WARNING, msg, System.err)
    }
    void error(String msg) {
        log(ERROR, msg, System.err)
    }
}