Dave Jarvis' Repositories

# always use LF line endings

# ALL FILES:

#   Normalize line endings to LF on checkin and

#   prevent conversion to CRLF when the file is checked out.

* text eol=lf

# BINARY FILES:

#   Disable line ending normalize on checkin.

*.gif binary

*.jar binary

*.png binary

*.zip binary

*.ttf binary

*.otf binary

*.blend binary

---

name: Bug report

about: Create a report to help us improve

title: ''

labels: bug

assignees: ''

---

**Description**

A concise problem description.

**Replicate**

Exact and complete steps to reproduce the problem 100% of the time:

1. Open '...'

1. Click '....'

1. Click '....'

**Expected**

Describe the expected behaviour.

**Actual**

Describe the actual behaviour.

**Screenshots**

Add screenshots to show the problem, if applicable.

**Environment**

 - Operating System: (Windows, Linux, Mac)

 - Application: e.g., 1.7.16

**Details**

Add additional information, if applicable.

dist

*.bin

*.exe

/*.jar

build

.gradle

contacted.csv

video

.settings

.classpath

.idea

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>Markdown Writer FX</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.jdt.core.javanature</nature>

		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>

	</natures>

	<filteredResources>

		<filter>

			<id>1438449113801</id>

			<name></name>

			<type>26</type>

			<matcher>

				<id>org.eclipse.ui.ide.multiFilter</id>

				<arguments>1.0-projectRelativePath-matches-false-false-build</arguments>

			</matcher>

		</filter>

		<filter>

			<id>1438449113801</id>

			<name></name>

			<type>26</type>

			<matcher>

				<id>org.eclipse.ui.ide.multiFilter</id>

				<arguments>1.0-projectRelativePath-matches-false-false-.gradle</arguments>

			</matcher>

		</filter>

	</filteredResources>

</projectDescription>

# Introduction

This document describes how to build the application and platform binaries.

# Requirements

Download and install the following software packages:

* [OpenJDK 14.0.2](https://openjdk.java.net) (full JDK, including JavaFX)

* [Gradle 6.4](https://gradle.org/releases)

* [Git 2.28.0](https://git-scm.com/downloads)

## Repository

Clone the repository as follows:

    git clone https://github.com/DaveJarvis/keenwrite.git

The repository is cloned.

# Build

Build the application überjar as follows:

    cd keenwrite

    gradle clean jar

The application is built.

# Run

After the application is compiled, run it as follows:

    java -jar build/libs/keenwrite.jar

On Windows:

    java -jar build\libs\keenwrite.jar

# Integrated development environments

This section describes setup instructions to import and run the application using an integrated development environment (IDE). Running the application should trigger a build.

## IntelliJ IDEA

This section describes how to build and run the application using IntellIJ's IDEA.

### Import

Complete the following steps to import the application:

1. Start the IDE.

1. Click **File → New → Project from Existing Sources**.

1. Browse to the directory containing `keenwrite`.

1. Click **OK**.

1. Select **Gradle** as the external model.

1. Click **Finish**.

The project is imported into the IDE.

### Run

Run the application as follows:

1. Ensure the **Project** is open.

1. Expand **src → main → java → com.keenwrite**.

1. Open **Launcher**.

1. Run **main**.

The application is launched.

# Installers

This section describes how to set up the development environment and build native executables for supported operating systems.

## Setup

Follow these one-time setup instructions to begin:

1. Ensure `$HOME/bin` is set in the `PATH` environment variable.

1. Copy `build-template` into `$HOME/bin`.

Setup is complete.

## Binaries

Run the `installer` script to build platform-specific binaries, such as:

    ./installer -V -o linux

The `installer` script:

* downloads a JDK;

* generates a run script;

* bundles the JDK, run script, and JAR file; and

* creates a standalone binary, so no installation required.

Run `./installer -h` to see all command-line options.

# Versioning

Version numbers are read directly from Git using a plugin. The version number is written to `app.properties` in the `resources` directory. The application reads that file to display version information upon start.

# Contributor Covenant Code of Conduct

## Our Pledge

In the interest of fostering an open and welcoming environment, we as

contributors and maintainers pledge to making participation in our project and

our community a harassment-free experience for everyone, regardless of age, body

size, disability, ethnicity, sex characteristics, gender identity and expression,

level of experience, education, socio-economic status, nationality, personal

appearance, race, religion, or sexual identity and orientation.

## Our Standards

Examples of behavior that contributes to creating a positive environment

include:

* Using welcoming and inclusive language

* Being respectful of differing viewpoints and experiences

* Gracefully accepting constructive criticism

* Focusing on what is best for the community

* Showing empathy towards other community members

Examples of unacceptable behavior by participants include:

* The use of sexualized language or imagery and unwelcome sexual attention or

 advances

* Trolling, insulting/derogatory comments, and personal or political attacks

* Public or private harassment

* Publishing others' private information, such as a physical or electronic

 address, without explicit permission

* Other conduct which could reasonably be considered inappropriate in a

 professional setting

## Our Responsibilities

Project maintainers are responsible for clarifying the standards of acceptable

behavior and are expected to take appropriate and fair corrective action in

response to any instances of unacceptable behavior.

Project maintainers have the right and responsibility to remove, edit, or

reject comments, commits, code, wiki edits, issues, and other contributions

that are not aligned to this Code of Conduct, or to ban temporarily or

permanently any contributor for other behaviors that they deem inappropriate,

threatening, offensive, or harmful.

## Scope

This Code of Conduct applies both within project spaces and in public spaces

when an individual is representing the project or its community. Examples of

representing a project or community include using an official project e-mail

address, posting via an official social media account, or acting as an appointed

representative at an online or offline event. Representation of a project may be

further defined and clarified by project maintainers.

## Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be

reported by contacting the project team at Dave.Jarvis@gmail.com. All

complaints will be reviewed and investigated and will result in a response that

is deemed necessary and appropriate to the circumstances. The project team is

obligated to maintain confidentiality with regard to the reporter of an incident.

Further details of specific enforcement policies may be posted separately.

Project maintainers who do not follow or enforce the Code of Conduct in good

faith may face temporary or permanent repercussions as determined by other

members of the project's leadership.

## Attribution

This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,

available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html

[homepage]: https://www.contributor-covenant.org

For answers to common questions about this code of conduct, see

https://www.contributor-covenant.org/faq

# License

Copyright 2020 White Magic Software, Ltd.

Copyright 2015 Karl Tauber

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright

  notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright

  notice, this list of conditions and the following disclaimer in the

  documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# R Functions

Import the files in this directory into the application, which include:

* pluralize.R

* possessive.R

* conversion.R

* csv.R

# pluralize.R

This file defines a function that implements most of Damian Conway's [An Algorithmic Approach to English Pluralization](http://blob.perl.org/tpc/1998/User_Applications/Algorithmic%20Approach%20Plurals/Algorithmic_Plurals.html).

## Usage

Example usages of the pluralize function include:

    `r#pluralize( 'mouse' )` - mice

    `r#pluralize( 'buzz' )` - buzzes

    `r#pluralize( 'bus' )` - busses

# possessive.R

This file defines a function that applies possessives to English words.

## Usage

Example usages of the possessive function include:

    `r#pos( 'Ross' )` - Ross'

    `r#pos( 'Ruby' )` - Ruby's

    `r#pos( 'Lois' )` - Lois'

    `r#pos( 'my' )` - mine

    `r#pos( 'Your' )` - Yours

setwd( '$application.r.working.directory$' )

assign( "anchor", '$date.anchor$', envir = .GlobalEnv )

source( 'pluralize.R' )

source( 'possessive.R' )

source( 'conversion.R' )

source( 'csv.R' )

# -----------------------------------------------------------------------------

# Copyright 2020, White Magic Software, Ltd.

# 

# Permission is hereby granted, free of charge, to any person obtaining

# a copy of this software and associated documentation files (the

# "Software"), to deal in the Software without restriction, including

# without limitation the rights to use, copy, modify, merge, publish,

# distribute, sublicense, and/or sell copies of the Software, and to

# permit persons to whom the Software is furnished to do so, subject to

# the following conditions:

# 

# The above copyright notice and this permission notice shall be

# included in all copies or substantial portions of the Software.

# 

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------

# Substitute R expressions in a document with their evaluated value. The

# anchor variable must be set for functions that use relative dates.

# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------

# Evaluates an expression; writes s if there is no expression.

# -----------------------------------------------------------------------------

x <- function( s ) {

  tryCatch( {

    r = eval( parse( text = s ) )

    # If the result isn't primitive, then it was probably parsed into

    # an unprintable object (e.g., "gray" becomes a colour). In those

    # cases, return the original text string. Otherwise, an atomic

    # value means a primitive type (string, integer, etc.) that can be

    # written directly into the document.

    ifelse( is.atomic( r ), r, s );

  },

  warning = function( w ) { s },

  error = function( e ) { s } )

}

# -----------------------------------------------------------------------------

# Returns a date offset by a given number of days, relative to the given

# date (d). This does not use the anchor, but is used to get the anchor's

# value as a date.

# -----------------------------------------------------------------------------

when <- function( d, n = 0, format = "%Y-%m-%d" ) {

  as.Date( d, format = format ) + x( n )

}

# -----------------------------------------------------------------------------

# Full date (s) offset by an optional number of days before or after.

# This will remove leading zeros (applying leading spaces instead, which

# are ignored by any worthwhile typesetting engine).

# -----------------------------------------------------------------------------

annal <- function( days = 0, format = "%Y-%m-%d", oformat = "%B %d, %Y" ) {

  format( when( anchor, days ), format = oformat )

}

# -----------------------------------------------------------------------------

# Extracts the year from a date string.

# -----------------------------------------------------------------------------

year <- function( days = 0, format = "%Y-%m-%d" ) {

  annal( days, format, "%Y" )

}

# -----------------------------------------------------------------------------

# Day of the week (in days since the anchor date).

# -----------------------------------------------------------------------------

weekday <- function( n ) {

  weekdays( when( anchor, n ) )

}

# -----------------------------------------------------------------------------

# String concatenate function alias because paste0 is a terrible name.

# -----------------------------------------------------------------------------

concat <- paste0

# -----------------------------------------------------------------------------

# Translates a number from digits to words using Chicago Manual of Style.

# This does not translate numbers greater than one hundred. If ordinal

# is TRUE, this will return the ordinal name. This will not produce ordinals

# for numbers greater than 100.

# -----------------------------------------------------------------------------

cms <- function( n, ordinal = FALSE ) {

  n <- x( n )

  if( n == 0 ) {

    if( ordinal ) {

      return( "zeroth" )

    }

    return( "zero" )

  }

  # Concatenate this a little later.

  if( n < 0 ) {

    result = "negative "

    n = abs( n )

  }

  # Do not spell out numbers greater than one hundred.

  if( n > 100 ) {

    # Comma-separated numbers.

    return( commas( n ) )

  }

  # Don't go beyond 100.

  if( n == 100 ) {

    if( ordinal ) {

      return( "one hundredth" )

    }

    return( "one hundred" )

  }

  # Samuel Langhorne Clemens noted English has too many exceptions.

  small = c(

    "one", "two", "three", "four", "five",

    "six", "seven", "eight", "nine", "ten",

    "eleven", "twelve", "thirteen", "fourteen", "fifteen",

    "sixteen", "seventeen", "eighteen", "nineteen"

  )

  ord_small = c(

    "first", "second", "third", "fourth", "fifth",

    "sixth", "seventh", "eighth", "ninth", "tenth",

    "eleventh", "twelfth", "thirteenth", "fourteenth", "fifteenth",

    "sixteenth", "seventeenth", "eighteenth", "nineteenth", "twentieth"

  )

  # After this, the number (n) is between 20 and 99.

  if( n < 20 ) {

    if( ordinal ) {

      return( .subset( ord_small, n %% 100 ) )

    }

    return( .subset( small, n %% 100 ) )

  }

  tens = c( "",

    "twenty", "thirty", "forty", "fifty",

    "sixty", "seventy", "eighty", "ninety"

  )

  ord_tens = c( "",

    "twentieth", "thirtieth", "fortieth", "fiftieth",

    "sixtieth", "seventieth", "eightieth", "ninetieth"

  )

  ones_index = n %% 10

  n = n %/% 10

  # No number in the ones column, so the number must be a multiple of ten.

  if( ones_index == 0 ) {

    if( ordinal ) {

      return( .subset( ord_tens, n ) )

    }

    return( .subset( tens, n ) )

  }

  # Find the value from the ones column.

  if( ordinal ) {

    unit_1 = .subset( ord_small, ones_index )

  }

  else {

    unit_1 = .subset( small, ones_index )

  }

  # Find the tens column.

  unit_10 = .subset( tens, n )

  # Hyphenate the tens and the ones together.

  concat( unit_10, concat( "-", unit_1 ) )

}

# -----------------------------------------------------------------------------

# Returns a number as a comma-delimited string. This is a work-around

# until Renjin fixes https://github.com/bedatadriven/renjin/issues/338

# -----------------------------------------------------------------------------

commas <- function( n ) {

  n <- x( n )

  s <- sprintf( "%03.0f", n %% 1000 )

  n <- n %/% 1000

  while( n > 0 ) {

    s <- concat( sprintf( "%03.0f", n %% 1000 ), ',', s )

    n <- n %/% 1000

  }

  gsub( '^0*', '', s )

}

# -----------------------------------------------------------------------------

# Returns a human-readable string that provides the elapsed time between

# two numbers in terms of years, months, and days. If any unit value is zero,

# the unit is not included. The words (year, month, day) are pluralized

# according to English grammar. The numbers are written out according to

# Chicago Manual of Style. This applies the serial comma.

#

# Both numbers are offsets relative to the anchor date.

#

# If all unit values are zero, this returns s ("same day" by default).

#

# If the start date (began) is greater than end date (ended), the dates are

# swapped before calculations are performed. This allows any two dates

# to be compared and positive unit values are always returned.

# -----------------------------------------------------------------------------

elapsed <- function( began, ended, s = "same day" ) {

  began = when( anchor, began )

  ended = when( anchor, ended )

  # Swap the dates if the end date comes before the start date.

  if( as.integer( ended - began ) < 0 ) {

    tempd = began

    began = ended

    ended = tempd

  }

  # Calculate number of elapsed years.

  years = length( seq( from = began, to = ended, by = 'year' ) ) - 1

  # Move the start date up by the number of elapsed years.

  if( years > 0 ) {

    began = seq( began, length = 2, by = concat( years, " years" ) )[2]

    years = pl.numeric( "year", years )

  }

  else {

    # Zero years.

    years = ""

  }

  # Calculate number of elapsed months, excluding years.

  months = length( seq( from = began, to = ended, by = 'month' ) ) - 1

  # Move the start date up by the number of elapsed months

  if( months > 0 ) {

    began = seq( began, length = 2, by = concat( months, " months" ) )[2]

    months = pl.numeric( "month", months )

  }

  else {

    # Zero months

    months = ""

  }

  # Calculate number of elapsed days, excluding months and years.

  days = length( seq( from = began, to = ended, by = 'day' ) ) - 1

  if( days > 0 ) {

    days = pl.numeric( "day", days )

  }

  else {

    # Zero days

    days = ""

  }

  if( years <= 0 && months <= 0 && days <= 0 ) {

    return( s )

  }

  # Put them all in a vector, then remove the empty values.

  s <- c( years, months, days )

  s <- s[ s != "" ]

  r <- paste( s, collapse = ", " )

  # If all three items are present, replace the last comma with ", and".

  if( length( s ) > 2 ) {

    return( gsub( "(.*),", "\\1, and", r ) )

  }

  # Does nothing if no commas are present.

  gsub( "(.*),", "\\1 and", r )

}

# -----------------------------------------------------------------------------

# Returns the number (n) in English followed by the plural or singular

# form of the given string (s; resumably a noun), if applicable, according

# to English grammar. That is, pl.numeric( "wolf", 5 ) will return

# "five wolves".

# -----------------------------------------------------------------------------

pl.numeric <- function( s, n ) {

  concat( cms( n ), concat( " ", pluralize( s, n ) ) )

}

# -----------------------------------------------------------------------------

# Pluralize s if n is not equal to 1.

# -----------------------------------------------------------------------------

pl <- function( s, n=2 ) {

  pluralize( s, x( n ) )

}

# -----------------------------------------------------------------------------

# Name of the season, starting with an capital letter.

# -----------------------------------------------------------------------------

season <- function( n, format = "%Y-%m-%d" ) {

  WS <- as.Date("2016-12-15", "%Y-%m-%d") # Winter Solstice

  SE <- as.Date("2016-03-15", "%Y-%m-%d") # Spring Equinox

  SS <- as.Date("2016-06-15", "%Y-%m-%d") # Summer Solstice

  AE <- as.Date("2016-09-15", "%Y-%m-%d") # Autumn Equinox

  d <- when( anchor, n )

  d <- as.Date( strftime( d, format="2016-%m-%d" ) )

  ifelse( d >= WS | d < SE, "Winter",

    ifelse( d >= SE & d < SS, "Spring",

      ifelse( d >= SS & d < AE, "Summer", "Autumn" )

    )

  )

}

# -----------------------------------------------------------------------------

# Converts the first letter in a string to lowercase

# -----------------------------------------------------------------------------

lc <- function( s ) {

  concat( tolower( substr( s, 1, 1 ) ), substr( s, 2, nchar( s ) ) )

}

# -----------------------------------------------------------------------------

# Converts the entire string to lowercase

# -----------------------------------------------------------------------------

lower <- tolower

# -----------------------------------------------------------------------------

# Converts the first letter in a string to uppercase

# -----------------------------------------------------------------------------

uc <- function( s ) {

  concat( toupper( substr( s, 1, 1 ) ), substr( s, 2, nchar( s ) ) )

}

# -----------------------------------------------------------------------------

# Returns the number of days between the given dates.

# -----------------------------------------------------------------------------

days <- function( d1, d2, format = "%Y-%m-%d" ) {

  dates = c( d1, d2 )

  dt = strptime( dates, format = format )

  as.integer( difftime( dates[2], dates[1], units = "days" ) )

}

# -----------------------------------------------------------------------------

# Returns the number of years elapsed.

# -----------------------------------------------------------------------------

years <- function( began, ended ) {

  began = when( anchor, began )

  ended = when( anchor, ended )

  # Swap the dates if the end date comes before the start date.

  if( as.integer( ended - began ) < 0 ) {

    tempd = began

    began = ended

    ended = tempd

  }

  # Calculate number of elapsed years.

  length( seq( from = began, to = ended, by = 'year' ) ) - 1

}

# -----------------------------------------------------------------------------

# Full name of the month, starting with a capital letter.

# -----------------------------------------------------------------------------

month <- function( n ) {

  # Faster than month.name[ x( n ) ]

  .subset( month.name, x( n ) )

}

# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------

money <- function( n ) {

  commas( x( n ) )

}

# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------

timeline <- function( n ) {

  concat( weekday( n ), ", ", annal( n ), " (", season( n ), ")" )

}

# -----------------------------------------------------------------------------

# Rounds to the nearest base value (e.g., round to nearest 10).

#

# @param base The nearest value to round to.

# -----------------------------------------------------------------------------

round.up <- function( n, base = 5 ) {

  base * round( x( n ) / base )

}

# -----------------------------------------------------------------------------

# Computes linear distance between two points using Haversine formula.

# Although Earth is an oblate spheroid, this will produce results close

# enough for most purposes.

#

# @param lat1/lon1 The source latitude and longitude.

# @param lat2/lon2 The destination latitude and longitude.

# @param radius The radius of the sphere.

#

# @return The distance between the two coordinates in meters.

# -----------------------------------------------------------------------------

haversine <- function( lat1, lon1, lat2, lon2, radius = 6371 ) {

  # Convert decimal degrees to radians

  lon1 = lon1 * pi / 180

  lon2 = lon2 * pi / 180

  lat1 = lat1 * pi / 180

  lat2 = lat2 * pi / 180

  # Haversine formula

  dlon = lon2 - lon1

  dlat = lat2 - lat1

  a = sin( dlat / 2 ) ** 2 + cos( lat1 ) * cos( lat2 ) * sin( dlon / 2 ) ** 2

  c = 2 * atan2( sqrt( a ), sqrt( 1-a ) )

  return( radius * c * 1000 )

}

# -----------------------------------------------------------------------------

# Copyright 2020, White Magic Software, Ltd.

# 

# Permission is hereby granted, free of charge, to any person obtaining

# a copy of this software and associated documentation files (the

# "Software"), to deal in the Software without restriction, including

# without limitation the rights to use, copy, modify, merge, publish,

# distribute, sublicense, and/or sell copies of the Software, and to

# permit persons to whom the Software is furnished to do so, subject to

# the following conditions:

# 

# The above copyright notice and this permission notice shall be

# included in all copies or substantial portions of the Software.

# 

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------

# Converts CSV to Markdown.

#

# Reads a CSV file and converts the contents to a Markdown table. The

# file must be in the working directory as specified by setwd.

#

# @param f The filename to convert.

# @param decimals Rounded decimal places (default 1).

# @param totals Include total sums (default TRUE).

# @param align Right-align numbers (default TRUE).

# -----------------------------------------------------------------------------

csv2md <- function( f, decimals = 2, totals = T, align = T ) {

  # Read the CVS data from the file; ensure strings become characters.

  df <- read.table( f, sep=',', header=T, stringsAsFactors=F )

  if( totals ) {

    # Determine what columns can be summed.

    number <- which( unlist( lapply( df, is.numeric ) ) )

    # Use colSums when more than one summable column exists.

    if( length( number ) > 1 ) {

      f.sum <- colSums

    }

    else {

      f.sum <- sum

    }

    # Calculate the sum of all the summable columns and insert the

    # results back into the data frame.

    df[ (nrow( df ) + 1), number ] <- f.sum( df[, number], na.rm=TRUE )

    # pluralise would be heavyweight here.

    if( length( number ) > 1 ) {

      t <- "**Totals**"

    }

    else {

      t <- "**Total**"

    }

    # Change the first column of the last line to "Total(s)".

    df[ nrow( df ), 1 ] <- t

    # Don't clutter the output with "NA" text.

    df[ is.na( df ) ] <- ""

  }

  if( align ) {

    is.char <- vapply( df, is.character, logical( 1 ) )

    dashes <- paste( ifelse( is.char, ':---', '---:' ), collapse='|' )

  }

  else {

    dashes <- paste( rep( '---', length( df ) ), collapse = '|' )

  }

  # Create a Markdown version of the data frame.

  paste(

    paste( names( df ), collapse = '|'), '\n',

    dashes, '\n', 

    paste(

      Reduce( function( x, y ) {

          paste( x, format( y, digits = decimals ), sep = '|' )

        }, df

      ),

      collapse = '|\n', sep=''

    )

  )

}

# -----------------------------------------------------------------------------

# Copyright 2020, White Magic Software, Ltd.

# 

# Permission is hereby granted, free of charge, to any person obtaining

# a copy of this software and associated documentation files (the

# "Software"), to deal in the Software without restriction, including

# without limitation the rights to use, copy, modify, merge, publish,

# distribute, sublicense, and/or sell copies of the Software, and to

# permit persons to whom the Software is furnished to do so, subject to

# the following conditions:

# 

# The above copyright notice and this permission notice shall be

# included in all copies or substantial portions of the Software.

# 

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------

# See Damian Conway's "An Algorithmic Approach to English Pluralization":

#   http://goo.gl/oRL4MP

# See Oliver Glerke's Evo Inflector: https://github.com/atteo/evo-inflector/

# See Shevek's Pluralizer: https://github.com/shevek/linguistics/

# See also: http://www.freevectors.net/assets/files/plural.txt

# -----------------------------------------------------------------------------

pluralize <- function( s, n ) {

  result <- s

  # Partial implementation of Conway's algorithm for nouns.

  if( n != 1 ) {

    if( pl.noninflective( s ) ||

        pl.suffix( "es", s ) ||

        pl.suffix( "fish", s ) ||

        pl.suffix( "ois", s ) ||

        pl.suffix( "sheep", s ) ||

        pl.suffix( "deer", s ) ||

        pl.suffix( "pox", s ) ||

        pl.suffix( "[A-Z].*ese", s ) ||

        pl.suffix( "itis", s ) ) {

      # 1. Retain non-inflective user-mapped noun as is.

      # 2. Retain non-inflective plural as is.

      result <- s

    }

    else if( pl.is.irregular.pl( s ) ) {

      # 4. Change irregular plurals based on mapping.

      result <- pl.irregular.pl( s )

    }

    else if( pl.is.irregular.es( s ) ) {

      # x. From Shevek's

      result <- pl.inflect( s, "", "es" )

    }

    else if( pl.suffix( "man", s ) ) {

      # 5. For -man, change -an to -en

      result <- pl.inflect( s, "an", "en" )

    }

    else if( pl.suffix( "[lm]ouse", s ) ) {

      # 5. For [lm]ouse, change -ouse to -ice

      result <- pl.inflect( s, "ouse", "ice" )

    }

    else if( pl.suffix( "tooth", s ) ) {

      # 5. For -tooth, change -ooth to -eeth

      result <- pl.inflect( s, "ooth", "eeth" )

    }

    else if( pl.suffix( "goose", s ) ) {

      # 5. For -goose, change -oose to -eese

      result <- pl.inflect( s, "oose", "eese" )

    }

    else if( pl.suffix( "foot", s ) ) {

      # 5. For -foot, change -oot to -eet

      result <- pl.inflect( s, "oot", "eet" )

    }

    else if( pl.suffix( "zoon", s ) ) {

      # 5. For -zoon, change -on to -a

      result <- pl.inflect( s, "on", "a" )

    }

    else if( pl.suffix( "[csx]is", s ) ) {

      # 5. Change -cis, -sis, -xis to -es

      result <- pl.inflect( s, "is", "es" )

    }

    else if( pl.suffix( "([cs]h|ss|zz|x|s)", s ) ) {

      # 8. Change -ch, -sh, -ss, -zz, -x, -s to -es

      result <- pl.inflect( s, "", "es" )

    }

    else if( pl.suffix( "([aeo]lf|[^d]eaf|arf)", s ) ) {

      # 9. Change -f to -ves

      result <- pl.inflect( s, "f", "ves" )

    }

    else if( pl.suffix( "[nlw]ife", s ) ) {

      # 10. Change -fe to -ves

      result <- pl.inflect( s, "fe", "ves" )

    }

    else if( pl.suffix( "[aeiou]y", s ) ) {

      # 11. Change -[aeiou]y to -ys

      result <- pl.inflect( s, "", "s" )

    }

    else if( pl.suffix( "y", s ) ) {

      # 12. Change -y to -ies

      result <- pl.inflect( s, "y", "ies" )

    }

    else if( pl.suffix( "z", s ) ) {

      # x. Change -z to -zzes

      result <- pl.inflect( s, "", "zes" )

    }

    else {

      # 13. Default plural: add -s

      result <- pl.inflect( s, "", "s" )

    }

  }

  result

}

# -----------------------------------------------------------------------------

# Returns the given string (s) with its suffix replaced by r.

# -----------------------------------------------------------------------------

pl.inflect <- function( s, suffix, r ) {

  gsub( paste( suffix, "$", sep="" ), r, s )

}

# -----------------------------------------------------------------------------

# Answers whether the given string (s) has the given ending.

# -----------------------------------------------------------------------------

pl.suffix <- function( ending, s ) {

  grepl( paste( ending, "$", sep="" ), s )

}

# -----------------------------------------------------------------------------

# Answers whether the given string (s) is a noninflective noun.

# -----------------------------------------------------------------------------

pl.noninflective <- function( s ) {

  v <- c(

    "aircraft",

    "Bhutanese",

    "bison",

    "bream",

    "Burmese",

    "carp",

    "chassis",

    "Chinese",

    "clippers",

    "cod",

    "contretemps",

    "corps",

    "debris",

    "djinn",

    "eland",

    "elk",

    "flounder",

    "fracas",

    "gallows",

    "graffiti",

    "headquarters",

    "high-jinks",

    "homework",

    "hovercraft",

    "innings",

    "Japanese",

    "Lebanese",

    "mackerel",

    "means",

    "mews",

    "mice",

    "mumps",

    "news",

    "pincers",

    "pliers",

    "Portuguese",

    "proceedings",

    "salmon",

    "scissors",

    "sea-bass",

    "Senegalese",

    "shears",

    "Siamese",

    "Sinhalese",

    "spacecraft",

    "swine",

    "trout",

    "tuna",

    "Vietnamese",

    "watercraft",

    "whiting",

    "wildebeest"

  )

  is.element( s, v )

}

# -----------------------------------------------------------------------------

# Answers whether the given string (s) is an irregular plural.

# -----------------------------------------------------------------------------

pl.is.irregular.pl <- function( s ) {

  # Could be refactored with pl.irregular.pl...

  v <- c(

    "beef", "brother", "child", "cow", "ephemeris", "genie", "money",

    "mongoose", "mythos", "octopus", "ox", "soliloquy", "trilby"

  )

  is.element( s, v )

}

# -----------------------------------------------------------------------------

# Call to pluralize an irregular noun. Only call after confirming

# the noun is irregular via pl.is.irregular.pl.

# -----------------------------------------------------------------------------

pl.irregular.pl <- function( s ) {

  v <- list(

    "beef" = "beefs",

    "brother" = "brothers",

    "child" = "children",

    "cow" = "cows",

    "ephemeris" = "ephemerides",

    "genie" = "genies",

    "money" = "moneys",

    "mongoose" = "mongooses",

    "mythos" = "mythoi",

    "octopus" = "octopuses",

    "ox" = "oxen",

    "soliloquy" = "soliloquies",

    "trilby" = "trilbys"

  )

  # Faster version of v[[ s ]]

  .subset2( v, s )

}

# -----------------------------------------------------------------------------

# Answers whether the given string (s) pluralizes with -es.

# -----------------------------------------------------------------------------

pl.is.irregular.es <- function( s ) {

  v <- c(

    "acropolis", "aegis", "alias", "asbestos", "bathos", "bias", "bronchitis",

    "bursitis", "caddis", "cannabis", "canvas", "chaos", "cosmos", "dais",

    "digitalis", "epidermis", "ethos", "eyas", "gas", "glottis", "hubris",

    "ibis", "lens", "mantis", "marquis", "metropolis", "pathos", "pelvis",

    "polis", "rhinoceros", "sassafrass", "trellis"

  )

  is.element( s, v )

}

# -----------------------------------------------------------------------------

# Copyright 2020, White Magic Software, Ltd.

# 

# Permission is hereby granted, free of charge, to any person obtaining

# a copy of this software and associated documentation files (the

# "Software"), to deal in the Software without restriction, including

# without limitation the rights to use, copy, modify, merge, publish,

# distribute, sublicense, and/or sell copies of the Software, and to

# permit persons to whom the Software is furnished to do so, subject to

# the following conditions:

# 

# The above copyright notice and this permission notice shall be

# included in all copies or substantial portions of the Software.

# 

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------

# Returns leftmost n characters of s.

# -----------------------------------------------------------------------------

lstr <- function( s, n = 1 ) {

  substr( s, 0, n )

}

# -----------------------------------------------------------------------------

# Returns rightmost n characters of s.

# -----------------------------------------------------------------------------

rstr <- function( s, n = 1 ) {

  l <- nchar( s )

  substr( s, l - n + 1, l )

}

# -----------------------------------------------------------------------------

# Returns the possessive form of the given word, s.

# -----------------------------------------------------------------------------

pos <- function( s ) {

  lcs <- tolower( s )

  pronouns <- c( 'your', 'our', 'her', 'it', 'their' )

  if( lcs == 'my' ) {

    # Change "[Mm]y" to "[Mm]ine".

    s <- paste0( lstr( s, 1 ), "ine" )

  }

  else if( lcs %in% pronouns ) {

    # Append an s to most pronouns.

    s <- paste0( s, 's' )

  }

  else if( lcs != 'his' ) {

    # Possessive for all other words except 'his'.

    s <- paste0( s, ifelse( rstr( s, 1 ) == 's', "'" ,"'s" ) )

  }

  s

}

# ![Logo](docs/images/app-title.png)

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

## Download

Download one of the following editions:

* [Windows](https://gitreleases.dev/gh/DaveJarvis/keenwrite/latest/keenwrite.exe)

* [Linux](https://gitreleases.dev/gh/DaveJarvis/keenwrite/latest/keenwrite.bin)

* [Java Archive](https://gitreleases.dev/gh/DaveJarvis/keenwrite/latest/keenwrite.jar)

## Run

Note that the first time the application runs, it will unpack itself into a local directory. Subsequent starts will be faster.

### Windows

Double-click the application to start; give the application permission to run.

When upgrading to a new version, delete the following directory:

    C:\Users\%USERNAME%\AppData\Local\warp\packages\keenwrite.exe

### Linux

Execute the following commands in a terminal:

``` bash

chmod +x keenwrite.bin

./keenwrite.bin

```

### Other

Download and install a full version of [OpenJDK 15](https://bell-sw.com/pages/downloads/?version=java-15#mn) that includes JavaFX module support, then run:

``` bash

java -jar keenwrite.jar

```

## Features

The application offers:

* User-defined interpolated strings

* Auto-complete variable names based on variable values

* Real-time spell check

* Real-time rendering of math using TeX notation

* Diagrams: Mermaid, GraphViz, UML, sequence, timing, DITAA, and more!

* R integration

* XML transformation using XSLT3 or older

* Customizable GUI having detachable tabs

* Platform independent (Windows, Linux, MacOS)

## Usage

See the [detailed documentation](docs/README.md) for information about

using the application.

## Screenshot

![Screenshot with Formulas](docs/images/equations.png)

## License

This software is licensed under the [BSD 2-Clause License](LICENSE.md) and

based on [Markdown-Writer-FX](licenses/MARKDOWN-WRITER-FX.md).

# ![Logo](docs/images/app-title.zh-CN.png)

智能写入是一个文本编辑器，它使用插值字符串引用外部定义的值。

## 下载

下载以下版本之一:

* [Windows](https://gitreleases.dev/gh/DaveJarvis/keenwrite/latest/keenwrite.exe)

* [Linux](https://gitreleases.dev/gh/DaveJarvis/keenwrite/latest/keenwrite.bin)

* [Java Archive](https://gitreleases.dev/gh/DaveJarvis/keenwrite/latest/keenwrite.jar)

## 跑

在第一次运行期间，应用程序将自身解压到本地目录中。随后的启动会更快。

### Windows

双击应用程序以启动。您必须授予应用程序运行权限。 

升级时，删除以下目录:

    C:\Users\%USERNAME%\AppData\Local\warp\packages\keenwrite.exe

### Linux

执行以下命令:

``` bash

chmod +x keenwrite.bin

./keenwrite.bin

```

### Other

Download and install a full version of [OpenJDK 15](https://bell-sw.com/pages/downloads/?version=java-15#mn) that includes JavaFX module support, then run:

``` bash

java -jar keenwrite.jar

```

## 特征

* 用户定义的插值字符串

* 带变量替换的实时预览

* 基于变量值自动完成变量名

* 使用XSLT3或更早版本的XML文档转换

* 独立于操作系统

* 打字时拼写检查

* 使用TeX的子集编写数学公式

* 嵌入R语句

## 软件使用

See the [detailed documentation](docs/README.md) for information about

using the application.

## 截图

![Screenshot with Formulas](docs/images/equations.png)

## 软件许可证

This software is licensed under the [BSD 2-Clause License](LICENSE.md) and

based on [Markdown-Writer-FX](licenses/MARKDOWN-WRITER-FX.md).

#!/usr/bin/env bash

# -----------------------------------------------------------------------------

# Copyright 2020 Dave Jarvis

#

# Permission is hereby granted, free of charge, to any person obtaining a

# copy of this software and associated documentation files (the

# "Software"), to deal in the Software without restriction, including

# without limitation the rights to use, copy, modify, merge, publish,

# distribute, sublicense, and/or sell copies of the Software, and to

# permit persons to whom the Software is furnished to do so, subject to

# the following conditions:

#

# The above copyright notice and this permission notice shall be included

# in all copies or substantial portions of the Software.

#

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

# -----------------------------------------------------------------------------

set -o errexit

set -o nounset

readonly SCRIPT_SRC="$(dirname "${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}")"

readonly SCRIPT_DIR="$(cd "${SCRIPT_SRC}" >/dev/null 2>&1 && pwd)"

readonly SCRIPT_NAME=$(basename "$0")

# -----------------------------------------------------------------------------

# The main entry point is responsible for parsing command-line arguments,

# changing to the appropriate directory, and running all commands requested

# by the user.

#

# $@ - Command-line arguments

# -----------------------------------------------------------------------------

main() {

  arguments "$@"

  $usage       && terminate 3

  requirements && terminate 4

  traps        && terminate 5

  directory    && terminate 6

  preprocess   && terminate 7

  execute      && terminate 8

  postprocess  && terminate 9

  terminate 0

}

# -----------------------------------------------------------------------------

# Perform all commands that the script requires.

#

# @return 0 - Indicate to terminate the script with non-zero exit level

# @return 1 - All tasks completed successfully (default)

# -----------------------------------------------------------------------------

execute() {

  return 1

}

# -----------------------------------------------------------------------------

# Changes to the script's working directory, provided it exists.

#

# @return 0 - Change directory failed

# @return 1 - Change directory succeeded

# -----------------------------------------------------------------------------

directory() {

  $log "Change directory"

  local result=1

  # Track whether change directory failed.

  cd "${SCRIPT_DIR}" > /dev/null 2>&1 || result=0

  return "${result}"

}

# -----------------------------------------------------------------------------

# Perform any initialization required prior to executing tasks.

#

# @return 0 - Preprocessing failed

# @return 1 - Preprocessing succeeded

# -----------------------------------------------------------------------------

preprocess() {

  $log "Preprocess"

  return 1

}

# -----------------------------------------------------------------------------

# Perform any clean up required prior to executing tasks.

#

# @return 0 - Postprocessing failed

# @return 1 - Postprocessing succeeded

# -----------------------------------------------------------------------------

postprocess() {

  $log "Postprocess"

  return 1

}

# -----------------------------------------------------------------------------

# Check that all required commands are available.

#

# @return 0 - At least one command is missing

# @return 1 - All commands are available

# -----------------------------------------------------------------------------

requirements() {

  $log "Verify requirements"

  local -r expected_count=${#DEPENDENCIES[@]}

  local total_count=0

  # Verify that each command exists.

  for dependency in "${DEPENDENCIES[@]}"; do

    # Extract the command name [0] and URL [1].

    IFS=',' read -ra dependent <<< "${dependency}"

    required "${dependent[0]}" "${dependent[1]}"

    total_count=$(( total_count + $? ))

  done

  unset IFS

  # Total dependencies found must match the expected number.

  # Integer-only division rounds down.

  return $(( total_count / expected_count ))

}

# -----------------------------------------------------------------------------

# Called before terminating the script.

# -----------------------------------------------------------------------------

cleanup() {

  $log "Cleanup"

}

# -----------------------------------------------------------------------------

# Terminates the program immediately.

# -----------------------------------------------------------------------------

trap_control_c() {

  $log "Interrupted"

  cleanup

  error "⯃"

  terminate 1

}

# -----------------------------------------------------------------------------

# Configure signal traps.

#

# @return 1 - Signal traps are set.

# -----------------------------------------------------------------------------

traps() {

  # Suppress echoing ^C if pressed.

  stty -echoctl

  trap trap_control_c INT

  return 1

}

# -----------------------------------------------------------------------------

# Check for a required command.

#

# $1 - Command or file to check for existence

# $2 - Command's website (e.g., download for binaries and source code)

#

# @return 0 - Command is missing

# @return 1 - Command exists

# -----------------------------------------------------------------------------

required() {

  local result=0

  test -f "$1" || \

  command -v "$1" > /dev/null 2>&1 && result=1 || \

    warning "Missing: $1 ($2)"

  return ${result}

}

# -----------------------------------------------------------------------------

# Show acceptable command-line arguments.

#

# @return 0 - Indicate script may not continue

# -----------------------------------------------------------------------------

utile_usage() {

  printf "Usage: %s [OPTIONS...]\n\n" "${SCRIPT_NAME}" >&2

  # Number of spaces to pad after the longest long argument.

  local -r PADDING=2

  # Determine the longest long argument to adjust spacing.

  local -r LEN=$(printf '%s\n' "${ARGUMENTS[@]}" | \

    awk -F"," '{print length($2)+'${PADDING}'}' | sort -n | tail -1)

  local duplicates

  for argument in "${ARGUMENTS[@]}"; do

    # Extract the short [0] and long [1] arguments and description [2].

    arg=("$(echo ${argument} | cut -d ',' -f1)" \

         "$(echo ${argument} | cut -d ',' -f2)" \

         "$(echo ${argument} | cut -d ',' -f3-)")

    duplicates+=("${arg[0]}")

    printf "  -%s, --%-${LEN}s%s\n" "${arg[0]}" "${arg[1]}" "${arg[2]}" >&2

  done

  # Sort the arguments to make sure no duplicates exist.

  duplicates=$(echo "${duplicates[@]}" | tr ' ' '\n' | sort | uniq -c -d)

  # Warn the developer that there's a duplicate command-line option.

  if [ -n "${duplicates}" ]; then

    # Trim all the whitespaces

    duplicates=$(echo "${duplicates}" | xargs echo -n)

    error "Duplicate command-line argument exists: ${duplicates}"

  fi

  return 0

}

# -----------------------------------------------------------------------------

# Write coloured text to standard output.

#

# $1 - Text to write

# $2 - Text's colour

# -----------------------------------------------------------------------------

coloured_text() {

  printf "%b%s%b\n" "$2" "$1" "${COLOUR_OFF}"

}

# -----------------------------------------------------------------------------

# Write a warning message to standard output.

#

# $1 - Text to write

# -----------------------------------------------------------------------------

warning() {

  coloured_text "$1" "${COLOUR_WARNING}"

}

# -----------------------------------------------------------------------------

# Write an error message to standard output.

#

# $1 - Text to write

# -----------------------------------------------------------------------------

error() {

  coloured_text "$1" "${COLOUR_ERROR}"

}

# -----------------------------------------------------------------------------

# Write a timestamp and message to standard output.