Dave Jarvis' Repositories

A text editor that uses [interpolated strings](https://en.wikipedia.org/wiki/String_interpolation) to reference externally defined values.

  def v_junit = '5.7.1'

  def v_jackson = '2.12.2'

  implementation 'com.miglayout:miglayout-javafx:5.2'

  implementation 'org.yaml:snakeyaml:1.27'

  // Configuration: Update Workspace to use Jackson, instead could shave ~800kb

  // Spelling, TeX, Docking

1. Download the <a href="https://github.com/DaveJarvis/keenwrite-themes/raw/main/theme-pack.zip">theme-pack.zip</a> archive.

import static com.keenwrite.util.MurmurHash.hash32;

import static java.lang.System.currentTimeMillis;

  private static final int SEED = (int) currentTimeMillis();

   * Hash the document so subscribers are only informed upon changes.

    final var hash = hash32( text, 0, text.length(), SEED );

    entry( KEY_TYPESET_CONTEXT_CLEAN, asBooleanProperty(true) ),

    entry( KEY_TYPESET_CONTEXT_THEME_SELECTION, asStringProperty( "boschet" ) )

/* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */

package com.keenwrite.preview;

import org.jsoup.helper.W3CDom;

import org.jsoup.nodes.Node;

import org.jsoup.nodes.TextNode;

import org.jsoup.select.NodeVisitor;

import org.w3c.dom.DOMImplementation;

import org.w3c.dom.Document;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import java.util.LinkedHashMap;

import java.util.Map;

import static com.keenwrite.events.StatusEvent.clue;

import static com.keenwrite.processors.text.TextReplacementFactory.replace;

/**

 * Responsible for converting JSoup document object model (DOM) to a W3C DOM.

 * Provides a lighter implementation than the superclass by overriding the

 * {@link #fromJsoup(org.jsoup.nodes.Document)} method to reuse factories,

 * builders, and implementations.

 */

final class DomConverter extends W3CDom {

  /**

   * Retain insertion order using an instance of {@link LinkedHashMap} so

   * that ligature substitution uses longer ligatures ahead of shorter

   * ligatures. The word "ruffian" should use the "ffi" ligature, not the "ff"

   * ligature.

   */

  private static final Map<String, String> LIGATURES = new LinkedHashMap<>();

  static {

    LIGATURES.put( "ffi", "\uFB03" );

    LIGATURES.put( "ffl", "\uFB04" );

    LIGATURES.put( "ff", "\uFB00" );

    LIGATURES.put( "fi", "\uFB01" );

    LIGATURES.put( "fl", "\uFB02" );

  }

  private static final NodeVisitor LIGATURE_VISITOR = new NodeVisitor() {

    @Override

    public void head( final Node node, final int depth ) {

      if( node instanceof final TextNode textNode ) {

        final var parent = node.parentNode();

        final var name = parent == null ? "root" : parent.nodeName();

        if( !("pre".equalsIgnoreCase( name ) ||

          "code".equalsIgnoreCase( name ) ||

          "tt".equalsIgnoreCase( name )) ) {

          // Calling getWholeText() will return newlines, which must be kept

          // to ensure that preformatted text maintains its formatting.

          textNode.text( replace( textNode.getWholeText(), LIGATURES ) );

        }

      }

    }

    @Override

    public void tail( final Node node, final int depth ) {

    }

  };

  private static final DocumentBuilderFactory DOCUMENT_FACTORY;

  private static DocumentBuilder DOCUMENT_BUILDER;

  private static DOMImplementation DOM_IMPL;

  static {

    DOCUMENT_FACTORY = DocumentBuilderFactory.newInstance();

    DOCUMENT_FACTORY.setNamespaceAware( true );

    try {

      DOCUMENT_BUILDER = DOCUMENT_FACTORY.newDocumentBuilder();

      DOM_IMPL = DOCUMENT_BUILDER.getDOMImplementation();

    } catch( final Exception ex ) {

      clue( ex );

    }

  }

  @Override

  public Document fromJsoup( final org.jsoup.nodes.Document in ) {

    assert in != null;

    assert DOCUMENT_BUILDER != null;

    assert DOM_IMPL != null;

    final var out = DOCUMENT_BUILDER.newDocument();

    final org.jsoup.nodes.DocumentType doctype = in.documentType();

    if( doctype != null ) {

      out.appendChild(

        DOM_IMPL.createDocumentType(

          doctype.name(),

          doctype.publicId(),

          doctype.systemId()

        )

      );

    }

    out.setXmlStandalone( true );

    in.traverse( LIGATURE_VISITOR );

    convert( in, out );

    return out;

  }

}

  private static final DomConverter CONVERTER = new DomConverter();

    "<link rel='stylesheet' href='%s'>";

    "<base href='%s'>";

      <html lang='%s'><head><title> </title><meta charset='utf-8'>

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import java.io.*;

import static java.nio.charset.StandardCharsets.UTF_8;

import static javax.xml.transform.OutputKeys.*;

  private static final TransformerFactory FACTORY_TRANSFORM =

    TransformerFactory.newInstance();

  private static final Transformer sTransformer;

  static {

    Transformer t;

    try {

      t = FACTORY_TRANSFORM.newTransformer();

      t.setOutputProperty( OMIT_XML_DECLARATION, "yes" );

      t.setOutputProperty( METHOD, "xml" );

      t.setOutputProperty( INDENT, "no" );

      t.setOutputProperty( ENCODING, UTF_8.name() );

    } catch( final Exception ignored ) {

      t = null;

    }

    sTransformer = t;

  }

   * @param e The DOM node to convert to a string.

  public static String toSvg( final Element e ) {

    try( final var writer = new StringWriter() ) {

      sTransformer.transform( new DOMSource( e ), new StreamResult( writer ) );

      return writer.toString().replaceAll( "xmlns=\"\" ", "" );

    // Otherwise, bolt on a processor that--after the interpolation and

      ? createHtmlPreviewProcessor()

      : createIdentityProcessor();

  private Processor<String> createIdentityProcessor() {

  private Processor<String> createHtmlPreviewProcessor() {

import org.jsoup.nodes.Document;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import java.util.Map.Entry;

import static javax.xml.transform.OutputKeys.INDENT;

import static javax.xml.transform.OutputKeys.OMIT_XML_DECLARATION;

import static org.jsoup.Jsoup.parse;

import static org.jsoup.nodes.Document.OutputSettings.Syntax;

 * Responsible for making an HTML document complete by wrapping it with html

    final var doc = parse( html );

    setMetaData( doc );

    doc.outputSettings().syntax( Syntax.xml );

    for( final var img : doc.getElementsByTag( "img" ) ) {

      try {

        final var imageFile = exportImage( img.attr( "src" ) );

        img.attr( "src", imageFile.toString() );

      } catch( final Exception ex ) {

        clue( ex );

      }

    return doc.html();

    doc.title( getTitle() );

    final var head = doc.head();

    metadata.entrySet().forEach( entry -> head.append( createMeta( entry ) ) );

  }

  private String createMeta( final Entry<String, String> entry ) {

    return format(

      "<meta name='%s' content='%s'>", entry.getKey(), entry.getValue()

      "author", getAuthor(),

      "byline", getByline(),

      "address", getAddress(),

      "phone", getPhone(),

      "email", getEmail(),

      "count", getWordCount( doc ),

      "keywords", getKeywords(),

      "copyright", getCopyright(),

      "date", getDate()

        sanitize( imageFile );

  }

  /**

   * Remove whitespace, comments, and XML/DOCTYPE declarations to make

   * processing work with ConTeXt.

   *

   * @param path The SVG file to process.

   * @throws Exception The file could not be processed.

   */

  private void sanitize( final Path path )

    throws Exception {

    final var file = path.toFile();

    final var dbf = DocumentBuilderFactory.newInstance();

    dbf.setIgnoringComments( true );

    dbf.setIgnoringElementContentWhitespace( true );

    final var db = dbf.newDocumentBuilder();

    final var document = db.parse( file );

    final var tf = TransformerFactory.newInstance();

    final var transformer = tf.newTransformer();

    final var source = new DOMSource( document );

    final var result = new StreamResult( file );

    transformer.setOutputProperty( OMIT_XML_DECLARATION, "yes" );

    transformer.setOutputProperty( INDENT, "no" );

    transformer.transform( source, result );

  private Locale getLocale() { return getWorkspace().getLocale(); }

  private String getTitle() {

  private String getAuthor() {

  private String getByline() {

  private String getAddress() {

  private String getPhone() {

  private String getEmail() {

  private String getWordCount( final Document doc ) {

    final var text = doc.wholeText();

    final var wordCounter = WordCounter.create( getLocale() );

    return valueOf( wordCounter.countWords( text ) );

  private String getKeywords() {

  private String getCopyright() {

  private String getDate() {

import com.vladsch.flexmark.ext.typographic.TypographicExtension;

import static com.keenwrite.ExportFormat.APPLICATION_PDF;

import static com.vladsch.flexmark.ext.typographic.TypographicExtension.ENABLE_SMARTS;

    // Disable emdash, endash, and ellipses conversion for PDF exports. The

    // typesetting software will perform the appropriate styling. This allows

    // manuscripts to include verbatim hyphens, for example.

    builder.set( ENABLE_SMARTS, !context.isExportFormat( APPLICATION_PDF ) );

   * Instantiates a number of extensions to be applied when parsing. These

   * are typically typographic extensions that convert characters into

   * HTML entities.

    if( !context.isExportFormat( APPLICATION_PDF ) ) {

      extensions.add( TypographicExtension.create() );

    }

/* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */

package com.keenwrite.quotes;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.util.AbstractMap.SimpleEntry;

import java.util.ArrayList;

import java.util.Map;

import java.util.function.Function;

import java.util.regex.Pattern;

import static java.util.Arrays.binarySearch;

import static java.util.Collections.sort;

/**

 * Responsible for converting straight quotes into smart quotes. This must be

 * used on plain text. The class will not parse HTML, TeX, or non-English text.

 */

public class SmartQuotes {

  /**

   * The main regex captures all words that contain an apostrophe. The terms

   * inner, outer, began, and ended define where the apostrophes can be found

   * in a particular word. The following text contains 3 word matches against

   * the "inner" pattern:

   *

   * <p>

   * 'Janes' said, ''E'll be spooky, Sam's son with the jack-o'-lantern!',"

   * said the O'Mally twins'---y'know---ghosts in unison.'

   * </p>

   */

  private static final Map<String, Pattern> PATTERNS = Map.ofEntries(

    // @formatter:off

    createEntry( "inner", "(?<![\\p{L}'])(?:\\p{L}+')+\\p{L}+(?![\\p{L}'])" ),

    createEntry( "began", "(?<!\\p{L})(?:'\\p{L}+)+(?![\\p{L}'])" ),

    createEntry( "ended", "(?<![\\p{L}'])(?:\\p{L}+')+(?!\\p{L})" ),

    createEntry( "outer", "(?<!\\p{L})'\\p{L}+'(?!\\p{L})" ),

    createEntry( "years", "'(?=\\d{2}s?)" ),

    createEntry( "+ings", "[\\p{L}]{2,}in'\\s?" ),

    createEntry( "prime", "((-?[0-9]\\d*(\\.\\d+)?)\\\\?'\\s?(-?[0-9]\\d*(\\.\\d+)?)\\\\?\")|((-?[0-9]\\d*(\\.\\d+)?)(''|\")\\s?(x|×)\\s?(-?[0-9]\\d*(\\.\\d+)?)(''|\"))|((-?[0-9]\\d*(\\.\\d+)?)'')" ),

    createEntry( "texop", "``" ),

    createEntry( "texcl", "''" ),

    createEntry( "white", "(?!\\s+)\"|\"(?!\\s+)" ),

    createEntry( "slash", "\\\\\"" )

    // @formatter:on

  );

  private static SimpleEntry<String, Pattern> createEntry(

    final String key, final String regex ) {

    return new SimpleEntry<>( key, Pattern.compile( regex ) );

  }

  /**

   * Left single quote replacement text.

   */

  private static final String QUOTE_SINGLE_LEFT = "‘";

  /**

   * Right single quote replacement text.

   */

  private static final String QUOTE_SINGLE_RIGHT = "’";

  /**

   * Left double quote replacement text.

   */

  private static final String QUOTE_DOUBLE_LEFT = "“";

  /**

   * Right double quote replacement text.

   */

  private static final String QUOTE_DOUBLE_RIGHT = "”";

  /**

   * Apostrophe replacement text.

   */

  private static final String APOSTROPHE = "'";

  /**

   * Prime replacement text.

   */

  private static final String SINGLE_PRIME = "′";

  /**

   * Double prime replacement text.

   */

  private static final String DOUBLE_PRIME = "″";

  /**

   * Temporary single quote marker near end of Unicode private use area.

   */

  private static final String SQ = "\uF8FE";

  /**

   * Temporary double quote marker near end of Unicode private use area.

   */

  private static final String DQ = "\uF8FD";

  private final Map<String, String[]> CONTRACTIONS = Map.ofEntries(

    load( "inner" ),

    load( "began" ),

    load( "ended" ),

    load( "outer" ),

    load( "verbs" )

  );

  public SmartQuotes() {

  }

  /**

   * Replaces straight single and double quotes with curly quotes or primes,

   * depending on the context.

   *

   * @param text The text that may contain straight single or double quotes.

   * @return All single and double quotes replaced with typographically

   * correct quotation marks.

   */

  public String replace( String text ) {

    // Replace known contractions.

    text = contractions( text );

    // Replace miscellaneous verb contractions.

    text = verbs( text );

    // Replace primes and double-primes (e.g., 5'4").

    text = primes( text );

    // Replace decade contractions.

    text = decades( text );

    // Replace contractions of words ending in "ing" (e.g., washin').

    text = suffixes( text );

    // Replace double backticks.

    text = backticks( text );

    // Unescape straight double quotes.

    text = escapes( text );

    return text;

  }

  /**

   * Replaces all strings in the given text that match the given pattern,

   * provided the functor answers {@code true} to the matched regex.

   *

   * @param text    The text to perform a replacement.

   * @param pattern The regular expression pattern to match.

   * @param filter  Controls whether a text replacement is made.

   * @return The given text with matching patterns replaced, conditionally.

   */

  private String replace( final String text,

                          final Pattern pattern,

                          final Function<String, Boolean> filter,

                          final Function<String, String> subst ) {

    final var sb = new StringBuilder( text.length() * 2 );

    final var matcher = pattern.matcher( text );

    while( matcher.find() ) {

      final var match = matcher.group( 0 );

      if( filter.apply( match ) ) {

        matcher.appendReplacement( sb, subst.apply( match ) );

      }

    }

    matcher.appendTail( sb );

    return sb.toString();

  }

  /**

   * Convenience method that always performs string replacement upon a match,

   * unconditionally.

   */

  private String apostrophize( final String text, final Pattern pattern ) {

    return apostrophize( text, pattern, ( match ) -> true );

  }

  private String apostrophize( final String text, final String pattern ) {

    return apostrophize( text, PATTERNS.get( pattern ) );

  }

  private String decades( final String text ) {

    return apostrophize( text, "years" );

  }

  private String suffixes( final String text ) {

    return apostrophize( text, "+ings" );

  }

  /**

   * Convenience method that replaces each straight quote in the given {@code

   * text} that passes through the given filter with an {@link #APOSTROPHE}.

   */

  private String apostrophize(

    final String text,

    final Pattern pattern,

    final Function<String, Boolean> filter ) {

    return replace(

      text,

      pattern,

      filter,

      ( match ) -> match.replaceAll( "'", APOSTROPHE ) );

  }

  private String contractions( String text ) {

    final var elements = new String[]{"inner", "began", "ended", "outer"};

    for( final var item : elements ) {

      final var pattern = PATTERNS.get( item );

      final var contractions = CONTRACTIONS.get( item );

      text = apostrophize(

        text,

        pattern,

        ( match ) -> binarySearch( contractions, match.toLowerCase() ) >= 0

      );

    }

    return text;

  }

  /**

   * Replaces verb endings, such as 'll and 've, with words not explicitly

   * listed as contractions in the dictionary sources.

   *

   * @param text The text to replace.

   * @return The given text with matching patterns replaced.

   */

  private String verbs( String text ) {

    for( final var contraction : CONTRACTIONS.get( "verbs" ) ) {

      final var pattern = Pattern.compile( "[\\p{L}]+" + contraction );

      text = apostrophize( text, pattern );

    }

    return text;

  }

  private String primes( final String text ) {

    System.out.println( "REPLACE: " + text);

    return replace(

      text,

      PATTERNS.get( "prime" ),

      ( match ) -> true,

      ( match ) -> match.replaceAll( "''", DOUBLE_PRIME )

                        .replaceAll( "\"", DOUBLE_PRIME )

                        .replaceAll( "'", SINGLE_PRIME )

                        .replaceAll( "\\\\", "" )

    );

  }

  /**

   * Replace all double backticks with opening double quote.

   */

  private String backticks( String text ) {

    final var sb = new StringBuilder( text.length() * 2 );

    final var opening = PATTERNS.get( "texop" );

    final var opener = opening.matcher( text );

    var count = 0;

    while( opener.find() ) {

      count++;

      opener.appendReplacement( sb, QUOTE_DOUBLE_LEFT );

    }

    opener.appendTail( sb );

    if( count > 0 ) {

      text = sb.toString();

      sb.setLength( 0 );

      final var closing = PATTERNS.get( "texcl" );

      final var closer = closing.matcher( text );

      while( count > 0 && closer.find() ) {

        count--;

        closer.appendReplacement( sb, QUOTE_DOUBLE_RIGHT );

      }

      closer.appendTail( sb );

    }

    return sb.toString();

  }

  private String escapes( final String text ) {

    return replace(

      text,

      PATTERNS.get( "slash" ),

      ( match ) -> true,

      ( match ) -> match.replaceAll( "\\\\", "" )

    );

  }

  /**

   * Reads the list of words containing contractions.

   */

  @SuppressWarnings( "SameParameterValue" )

  private SimpleEntry<String, String[]> load( final String prefix ) {

    // Allocate enough elements to hold all the contractions.

    final var result = new ArrayList<String>( 1024 );

    try( final var in = openResource( prefix + ".txt" ) ) {

      for( String line; ((line = in.readLine()) != null); ) {

        result.add( line );

      }

      sort( result );

    } catch( final Exception ex ) {

      throw new RuntimeException( ex );

    }

    return new SimpleEntry<>( prefix, result.toArray( new String[ 0 ] ) );

  }

  private BufferedReader openResource( final String filename ) {

    final var in = getClass().getResourceAsStream( filename );

    assert in != null;

    return new BufferedReader( new InputStreamReader( in ) );

  }

}

  private Properties read( final Path file ) throws IOException {

    try( final var in = new FileInputStream( file.toFile() ) ) {

import com.keenwrite.util.MurmurHash;

import org.jsoup.Jsoup;

   * Called when the hashcode for the current document changes. This happens

   * document is sent to {@link HtmlPanel} for rendering, the parsed

   * {@link Jsoup} document is converted to text. If that text differs

   * (using {@link MurmurHash}), then this method is called. The implication

   * is that all variables and executable statements have been replaced.

   * An event bus subscriber is used so that text processing occurs outside

   * of the UI processing threads.

        final var wordCount = mWordCounter.countWords(

  public int countWords( final String document ) {

    return countWords( document, ( k, count ) -> {} );

  public int countWords(

package com.keenwrite.util;

/**

 * The MurmurHash3 algorithm was created by Austin Appleby and placed in the

 * public domain. This Java port was authored by Yonik Seeley and also placed

 * into the public domain. The author hereby disclaims copyright to this

 * source code.

 * <p>

 * This produces exactly the same hash values as the final C++ version and is

 * thus suitable for producing the same hash values across platforms.

 * <p>

 * The 32-bit x86 version of this hash should be the fastest variant for

 * relatively short keys like ids. Using {@link #hash32} is a

 * good choice for longer strings or returning more than 32 hashed bits.

 * <p>

 * The x86 and x64 versions do not produce the same results because

 * algorithms are optimized for their respective platforms.

 * <p>

 * Code clean-up by White Magic Software, Ltd.

 * </p>

 */

public final class MurmurHash {

  /**

   * Returns the 32-bit x86-optimized hash of the UTF-8 bytes of the String

   * without actually encoding the string to a temporary buffer. This is over

   * twice as fast as hashing the result of {@link String#getBytes()}.

   */

  @SuppressWarnings( "unused" )

  public static int hash32( CharSequence data, int offset, int len, int seed ) {

    final int c1 = 0xcc9e2d51;

    final int c2 = 0x1b873593;

    int h1 = seed;

    int pos = offset;

    int end = offset + len;

    int k1 = 0;

    int k2;

    int shift = 0;

    int bits;

    int nBytes = 0;   // length in UTF8 bytes

    while( pos < end ) {

      int code = data.charAt( pos++ );

      if( code < 0x80 ) {

        k2 = code;

        bits = 8;

      }

      else if( code < 0x800 ) {

        k2 = (0xC0 | (code >> 6))

          | ((0x80 | (code & 0x3F)) << 8);

        bits = 16;

      }

      else if( code < 0xD800 || code > 0xDFFF || pos >= end ) {

        // we check for pos>=end to encode an unpaired surrogate as 3 bytes.

        k2 = (0xE0 | (code >> 12))

          | ((0x80 | ((code >> 6) & 0x3F)) << 8)

          | ((0x80 | (code & 0x3F)) << 16);

        bits = 24;

      }

      else {

        // surrogate pair

        // int utf32 = pos < end ? (int) data.charAt(pos++) : 0;

        int utf32 = data.charAt( pos++ );

        utf32 = ((code - 0xD7C0) << 10) + (utf32 & 0x3FF);

        k2 = (0xff & (0xF0 | (utf32 >> 18)))

          | ((0x80 | ((utf32 >> 12) & 0x3F))) << 8

          | ((0x80 | ((utf32 >> 6) & 0x3F))) << 16

          | (0x80 | (utf32 & 0x3F)) << 24;

        bits = 32;

      }

      k1 |= k2 << shift;

      // int used_bits = 32 - shift;  // how many bits of k2 were used in k1.

      // int unused_bits = bits - used_bits; //  (bits-(32-shift)) ==

      // bits+shift-32  == bits-newshift

      shift += bits;

      if( shift >= 32 ) {

        // mix after we have a complete word

        k1 *= c1;

        k1 = (k1 << 15) | (k1 >>> 17);  // ROTL32(k1,15);

        k1 *= c2;

        h1 ^= k1;

        h1 = (h1 << 13) | (h1 >>> 19);  // ROTL32(h1,13);

        h1 = h1 * 5 + 0xe6546b64;

        shift -= 32;

        // unfortunately, java won't let you shift 32 bits off, so we need to

        // check for 0

        if( shift != 0 ) {

          k1 = k2 >>> (bits - shift);   // bits used == bits - newshift

        }

        else {

          k1 = 0;

        }

        nBytes += 4;

      }

    } // inner

    // handle tail

    if( shift > 0 ) {

      nBytes += shift >> 3;

      k1 *= c1;

      k1 = (k1 << 15) | (k1 >>> 17);  // ROTL32(k1,15);

      k1 *= c2;

      h1 ^= k1;

    }

    // finalization

    h1 ^= nBytes;

    // fmix(h1);

    h1 ^= h1 >>> 16;

    h1 *= 0x85ebca6b;

    h1 ^= h1 >>> 13;

    h1 *= 0xc2b2ae35;

    h1 ^= h1 >>> 16;

    return h1;

  }

}

/* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */

package com.keenwrite.quotes;

import org.junit.jupiter.api.Disabled;

import org.junit.jupiter.api.Test;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import static org.junit.jupiter.api.Assertions.assertEquals;

import static org.junit.jupiter.api.Assertions.assertNotNull;