Dave Jarvis' Repositories

      .with( Mutator::setThemeDir, w::getThemesPath )

      .with( Mutator::setCacheDir,

             () -> w.getFile( KEY_CACHE_DIR ) )

      .with( Mutator::setImageDir,

             () -> w.getFile( KEY_IMAGE_DIR ) )

             () -> w.getString( KEY_IMAGE_ORDER ) )

             () -> w.getString( KEY_IMAGE_SERVER ) )

      .with( Mutator::setFontDir,

      .with( Mutator::setThemeDir, () -> mThemesDir )

      .with( Mutator::setCacheDir, () -> mCachesDir )

      .with( Mutator::setImageDir, () -> mImagesDir )

      .with( Mutator::setFontDir, () -> mFontDir )

   * Default working directory.

  /**

   * Location to write temporary files.

   */

  public static final String TEMPORARY_DIRECTORY =

    System.getProperty( "java.io.tmpdir" );

  public static final Key KEY_IMAGE = key( KEY_ROOT, "images" );

  public static final Key KEY_CACHE_DIR = key( KEY_IMAGE, "cache" );

  public static final Key KEY_IMAGE_DIR = key( KEY_IMAGE, "dir" );

  public static final Key KEY_IMAGE_ORDER = key( KEY_IMAGE, "order" );

  public static final Key KEY_IMAGE_RESIZE = key( KEY_IMAGE, "resize" );

  public static final Key KEY_IMAGE_SERVER = key( KEY_IMAGE, "server" );

        get( KEY_IMAGE ),

          get( KEY_IMAGE_DIR ),

          Setting.of( label( KEY_IMAGE_DIR ) ),

          Setting.of( title( KEY_IMAGE_DIR ),

                      directoryProperty( KEY_IMAGE_DIR ),

          Setting.of( label( KEY_CACHE_DIR ) ),

          Setting.of( title( KEY_CACHE_DIR ),

                      directoryProperty( KEY_CACHE_DIR ),

          get( KEY_IMAGE_ORDER ),

          Setting.of( label( KEY_IMAGE_ORDER ) ),

          Setting.of( title( KEY_IMAGE_ORDER ),

                      stringProperty( KEY_IMAGE_ORDER ) )

          get( KEY_IMAGE_RESIZE ),

          Setting.of( label( KEY_IMAGE_RESIZE ) ),

          Setting.of( title( KEY_IMAGE_RESIZE ),

                      booleanProperty( KEY_IMAGE_RESIZE ) )

          get( KEY_IMAGE_SERVER ),

          Setting.of( label( KEY_IMAGE_SERVER ) ),

          Setting.of( title( KEY_IMAGE_SERVER ),

                      stringProperty( KEY_IMAGE_SERVER ) )

    entry( KEY_CACHE_DIR, asFileProperty( USER_CACHE_DIR ) ),

    entry( KEY_IMAGE_DIR, asFileProperty( USER_DIRECTORY ) ),

    entry( KEY_IMAGE_ORDER, asStringProperty( PERSIST_IMAGES_DEFAULT ) ),

    entry( KEY_IMAGE_RESIZE, asBooleanProperty( true ) ),

    entry( KEY_IMAGE_SERVER, asStringProperty( DIAGRAM_SERVER_NAME ) ),

    if( mWorkspace.getBoolean( KEY_IMAGE_RESIZE ) ) {

      final var targetPath = context.getTargetPath();

      clue( "Main.status.typeset.setting", "target", targetPath );

      final var parent = targetPath.toAbsolutePath().getParent();

      final var document = TEXT_XML.createTempFile( APP_TITLE_ABBR, parent );

      final var sourcePath = writeString( document, xhtml );

      clue( "Main.status.typeset.setting", "source", sourcePath );

      final var themeDir = context.getThemeDir();

      clue( "Main.status.typeset.setting", "themes", themeDir );

      final var imageDir = context.getImageDir();

      clue( "Main.status.typeset.setting", "images", imageDir );

      final var cacheDir = context.getCacheDir();

      clue( "Main.status.typeset.setting", "caches", cacheDir );

      final var fontDir = context.getFontDir();

      clue( "Main.status.typeset.setting", "fonts", fontDir );

      final var autoRemove = context.getAutoRemove();

      clue( "Main.status.typeset.setting", "purge", autoRemove );

      final var rWorkDir = context.getRWorkingDir();

      clue( "Main.status.typeset.setting", "r-work", rWorkDir );

      final var imageOrder = context.getImageOrder();

      clue( "Main.status.typeset.setting", "order", imageOrder );

        .with( Mutator::setSourcePath, sourcePath )

        .with( Mutator::setTargetPath, targetPath )

        .with( Mutator::setThemeDir, themeDir )

        .with( Mutator::setImageDir, imageDir )

        .with( Mutator::setCacheDir, cacheDir )

        .with( Mutator::setFontDir, fontDir )

        .with( Mutator::setAutoRemove, autoRemove )

import static com.keenwrite.predicates.PredicateFactory.createFileTypePredicate;

/**

 * Provides a context for configuring a chain of {@link Processor} instances.

 */

public final class ProcessorContext {

  private final Mutator mMutator;

  /**

   * Determines the file type from the path extension. This should only be

   * called when it is known that the file type won't be a definition file

   * (e.g., YAML or other definition source), but rather an editable file

   * (e.g., Markdown, R Markdown, etc.).

   *

   * @param path The path with a file name extension.

   * @return The FileType for the given path.

   */

  private static FileType lookup( final Path path ) {

    assert path != null;

    final var prefix = GLOB_PREFIX_FILE;

    final var keys = sSettings.getKeys( prefix );

    var found = false;

    var fileType = UNKNOWN;

    while( keys.hasNext() && !found ) {

      final var key = keys.next();

      final var patterns = sSettings.getStringSettingList( key );

      final var predicate = createFileTypePredicate( patterns );

      if( predicate.test( path.toFile() ) ) {

        // Remove the EXTENSIONS_PREFIX to get the file name extension mapped

        // to a standard name (as defined in the settings.properties file).

        final String suffix = key.replace( prefix + '.', "" );

        fileType = FileType.from( suffix );

        found = true;

      }

    }

    return fileType;

  }

  public boolean isExportFormat( final ExportFormat exportFormat ) {

    return mMutator.mExportFormat == exportFormat;

  }

  /**

   * Responsible for populating the instance variables required by the

   * context.

   */

  public static class Mutator {

    private Path mSourcePath;

    private Path mTargetPath;

    private ExportFormat mExportFormat;

    private Supplier<Boolean> mConcatenate = () -> true;

    private Supplier<String> mChapters = () -> "";

    private Supplier<Path> mThemeDir = USER_DIRECTORY::toPath;

    private Supplier<Locale> mLocale = () -> Locale.ENGLISH;

    private Supplier<Map<String, String>> mDefinitions = HashMap::new;

    private Supplier<Map<String, String>> mMetadata = HashMap::new;

    private Supplier<Caret> mCaret = () -> Caret.builder().build();

    private Supplier<Path> mFontDir = () -> getFontDirectory().toPath();

    private Supplier<Path> mImageDir = USER_DIRECTORY::toPath;

    private Supplier<String> mImageServer = () -> DIAGRAM_SERVER_NAME;

    private Supplier<String> mImageOrder = () -> PERSIST_IMAGES_DEFAULT;

    private Supplier<Path> mCacheDir = USER_CACHE_DIR::toPath;

    private Supplier<String> mSigilBegan = () -> DEF_DELIM_BEGAN_DEFAULT;

    private Supplier<String> mSigilEnded = () -> DEF_DELIM_ENDED_DEFAULT;

    private Supplier<Path> mRWorkingDir = USER_DIRECTORY::toPath;

    private Supplier<String> mRScript = () -> "";

    private Supplier<Boolean> mCurlQuotes = () -> true;

    private Supplier<Boolean> mAutoRemove = () -> true;

    public void setSourcePath( final Path sourcePath ) {

      assert sourcePath != null;

      mSourcePath = sourcePath;

    }

    public void setTargetPath( final Path outputPath ) {

      assert outputPath != null;

      mTargetPath = outputPath;

    }

    public void setThemeDir( final Supplier<Path> themeDir ) {

      assert themeDir != null;

      mThemeDir = themeDir;

    }

    public void setCacheDir( final Supplier<File> cacheDir ) {

      assert cacheDir != null;

      mCacheDir = () -> {

        final var dir = cacheDir.get();

        return (dir == null ? USER_DATA_DIR.toFile() : dir).toPath();

      };

    }

    public void setImageDir( final Supplier<File> imageDir ) {

      assert imageDir != null;

      mImageDir = () -> {

        final var dir = imageDir.get();

        return (dir == null ? USER_DIRECTORY : dir).toPath();

      };

    }

    public void setImageOrder( final Supplier<String> imageOrder ) {

      assert imageOrder != null;

      mImageOrder = imageOrder;

    }

    public void setImageServer( final Supplier<String> imageServer ) {

      assert imageServer != null;

      mImageServer = imageServer;

    }

    public void setFontDir( final Supplier<File> fontDir ) {

      assert fontDir != null;

      mFontDir = () -> {

        final var dir = fontDir.get();

        return (dir == null ? USER_DIRECTORY : dir).toPath();

      };

    }

    public void setExportFormat( final ExportFormat exportFormat ) {

      assert exportFormat != null;

      mExportFormat = exportFormat;

    }

    public void setConcatenate( final Supplier<Boolean> concatenate ) {

      mConcatenate = concatenate;

    }

    public void setChapters( final Supplier<String> chapters ) {

      mChapters = chapters;

    }

    public void setLocale( final Supplier<Locale> locale ) {

      assert locale != null;

      mLocale = locale;

    }

    /**

     * Sets the list of fully interpolated key-value pairs to use when

     * substituting variable names back into the document as variable values.

     * This uses a {@link Callable} reference so that GUI and command-line

     * usage can insert their respective behaviours. That is, this method

     * prevents coupling the GUI to the CLI.

     *

     * @param supplier Defines how to retrieve the definitions.

     */

    public void setDefinitions( final Supplier<Map<String, String>> supplier ) {

      assert supplier != null;

      mDefinitions = supplier;

    }

    public void setMetadata( final Supplier<Map<String, String>> metadata ) {

      assert metadata != null;

      mMetadata = metadata.get() == null ? HashMap::new : metadata;

    }

    /**

     * Sets the source for deriving the {@link Caret}. Typically, this is

     * the text editor that has focus.

     *

     * @param caret The source for the currently active caret.

     */

    public void setCaret( final Supplier<Caret> caret ) {

      assert caret != null;

      mCaret = caret;

    }

    public void setSigilBegan( final Supplier<String> sigilBegan ) {

      assert sigilBegan != null;

      mSigilBegan = sigilBegan;

    }

    public void setSigilEnded( final Supplier<String> sigilEnded ) {

      assert sigilEnded != null;

      mSigilEnded = sigilEnded;

    }

    public void setRWorkingDir( final Supplier<Path> rWorkingDir ) {

      assert rWorkingDir != null;

      mRWorkingDir = rWorkingDir;

    }

    public void setRScript( final Supplier<String> rScript ) {

      assert rScript != null;

      mRScript = rScript;

    }

    public void setCurlQuotes( final Supplier<Boolean> curlQuotes ) {

      assert curlQuotes != null;

      mCurlQuotes = curlQuotes;

    }

    public void setAutoRemove( final Supplier<Boolean> autoRemove ) {

      assert autoRemove != null;

      mAutoRemove = autoRemove;

    }

    private boolean isExportFormat( final ExportFormat format ) {

      return mExportFormat == format;

    }

  }

  public static GenericBuilder<Mutator, ProcessorContext> builder() {

    return GenericBuilder.of( Mutator::new, ProcessorContext::new );

  }

  /**

   * Creates a new context for use by the {@link ProcessorFactory} when

   * instantiating new {@link Processor} instances. Although all the

   * parameters are required, not all {@link Processor} instances will use

   * all parameters.

   */

  private ProcessorContext( final Mutator mutator ) {

    assert mutator != null;

    mMutator = mutator;

  }

  public Path getSourcePath() {

    return mMutator.mSourcePath;

  }

  /**

   * Answers what type of input document is to be processed.

   *

   * @return The input document's {@link MediaType}.

   */

  public MediaType getSourceType() {

    return MediaTypeExtension.fromPath( mMutator.mSourcePath );

  }

  /**

   * Fully qualified file name to use when exporting (e.g., document.pdf).

   *

   * @return Full path to a file name.

   */

  public Path getTargetPath() {

    return mMutator.mTargetPath;

  }

  public ExportFormat getExportFormat() {

    return mMutator.mExportFormat;

  }

  public Locale getLocale() {

    return mMutator.mLocale.get();

  }

  /**

   * Returns the variable map of definitions, without interpolation.

   *

   * @return A map to help dereference variables.

   */

  public Map<String, String> getDefinitions() {

    return mMutator.mDefinitions.get();

  }

  /**

   * Returns the variable map of definitions, with interpolation.

   *

   * @return A map to help dereference variables.

   */

  public InterpolatingMap getInterpolatedDefinitions() {

    return new InterpolatingMap(

      createDefinitionKeyOperator(), getDefinitions()

    ).interpolate();

  }

  public Map<String, String> getMetadata() {

    return mMutator.mMetadata.get();

  }

  /**

   * Returns the current caret position in the document being edited and is

   * always up-to-date.

   *

   * @return Caret position in the document.

   */

  public Supplier<Caret> getCaret() {

    return mMutator.mCaret;

  }

  /**

   * Returns the directory that contains the file being edited. When

   * {@link Constants#DOCUMENT_DEFAULT} is created, the parent path is

   * {@code null}. This will get absolute path to the file before trying to

   * get te parent path, which should always be a valid path. In the unlikely

   * event that the base path cannot be determined by the path alone, the

   * default user directory is returned. This is necessary for the creation

   * of new files.

   *

   * @return Path to the directory containing a file being edited, or the

   * default user directory if the base path cannot be determined.

   */

  public Path getBaseDir() {

    final var path = getSourcePath().toAbsolutePath().getParent();

    return path == null ? DEFAULT_DIRECTORY : path;

  }

  FileType getSourceFileType() {

    return lookup( getSourcePath() );

  }

  public Path getThemeDir() {

    return mMutator.mThemeDir.get();

  }

  public Path getImageDir() {

    return mMutator.mImageDir.get();

  }

  public Path getCacheDir() {

    return mMutator.mCacheDir.get();

  }

  public Iterable<String> getImageOrder() {

    assert mMutator.mImageOrder != null;

    final var order = mMutator.mImageOrder.get();

    final var token = order.contains( "," ) ? ',' : ' ';

    return Splitter.on( token ).split( token + order );

  }

  public String getImageServer() {

    return mMutator.mImageServer.get();

  }

  public Path getFontDir() {

    return mMutator.mFontDir.get();

    return mContext.getImageDir();

    return mContext.getCacheDir();

      return mContext.getImageDir();

    final var themesPath = getThemeDir();

    final var imagesDir = normalize( getImageDir() );

    final var cachesDir = normalize( getCacheDir() );

    final var fontsDir = normalize( getFontDir() );

import static com.keenwrite.constants.Constants.TEMPORARY_DIRECTORY;

      final var cache = Path.of( TEMPORARY_DIRECTORY, "luatex-cache" );

import static com.keenwrite.Bootstrap.USER_CACHE_DIR;

import static com.keenwrite.constants.Constants.USER_DIRECTORY;

import static com.keenwrite.constants.Constants.getFontDirectory;

    private Path mThemeDir = USER_DIRECTORY.toPath();

    private Path mImageDir = USER_DIRECTORY.toPath();

    private Path mCacheDir = USER_CACHE_DIR.toPath();

    private Path mFontDir = getFontDirectory().toPath();

     * @param themeDir Fully qualified path to the theme directory, which

     *                 ends with the selected theme name.

    public void setThemeDir( final Path themeDir ) {

      mThemeDir = themeDir;

     * @param imageDir Fully qualified path to the "images" directory.

    public void setImageDir( final Path imageDir ) {

      mImageDir = imageDir;

     * @param cacheDir Fully qualified path to the "caches" directory.

    public void setCacheDir( final Path cacheDir ) {

      mCacheDir = cacheDir;

     * @param fontDir Fully qualified path to the "fonts" directory.

    public void setFontDir( final Path fontDir ) {

      mFontDir = fontDir;

    public Path getThemeDir() {

      return mThemeDir;

    public Path getImageDir() {

      return mImageDir;

    public Path getCacheDir() {

      return mCacheDir;

    public Path getFontDir() {

      return mFontDir;

    final var themesPath = getThemeDir();

    final var imagesPath = getImageDir();

    final var cachesPath = getCacheDir();

              themesPath, imagesPath, cachesPath )

  protected Path getThemeDir() {

    return mMutator.getThemeDir();

  protected Path getImageDir() {

    return mMutator.getImageDir();

  protected Path getCacheDir() {

    return mMutator.getCacheDir();

  protected Path getFontDir() {

    return mMutator.getFontDir();

Main.status.typeset.setting=Set {0} to ''{1}''

      .with( ProcessorContext.Mutator::setThemeDir, () -> Path.of( "b" ) )

      .with( ProcessorContext.Mutator::setImageDir, () -> new File( "i" ) )

      .with( ProcessorContext.Mutator::setImageDir, imagesDir::toFile )