Update documentation, update functions, bug fixes, for building against newer version of Lilypond (2.24.2).

Author: leonawicz

NAMESPACE

@@ -93,11 +93,12 @@ S3method(tail,music)
 S3method(tail,noteinfo)
 S3method(tail,noteworthy)
 S3method(time_format,character)
+S3method(time_format,double)
 S3method(time_format,lyrics)
 S3method(time_format,music)
 S3method(time_format,noteinfo)
 S3method(time_format,noteworthy)
-export("%>%")
+S3method(time_format,numeric)
 export(accidental_type)
 export(as_integer_octaves)
 export(as_lyrics)
@@ -404,10 +405,9 @@ export(xm9)
 export(xma9)
 export(xs2)
 export(xs4)
-importFrom(dplyr,tibble)
 importFrom(graphics,par)
 importFrom(graphics,plot.new)
 importFrom(graphics,rasterImage)
-importFrom(magrittr,"%>%")
+importFrom(tibble,tibble)
 importFrom(utils,head)
 importFrom(utils,tail)

R/chord_mapping.R

@@ -4,40 +4,39 @@
 #'
 #' This function creates a tibble data frame containing information defining
 #' various attributes of chords.
-#' It is used to create the \code{guitarChords} dataset, but can be used to
-#' create other pre-defined chord collections.
+#' It is used to create the `guitarChords` dataset, but can be used to create
+#' other pre-defined chord collections.
 #' The tibble has only one row, providing all information for the defined chord.
 #' The user can decide which arguments to vectorize over when creating a chord
 #' collection. See examples.
 #'
-#' This function uses a vector of fret integers (\code{NA} for muted string) to
-#' define a chord, in conjunction with a string \code{tuning} (defaults to
-#' standard tuning, six-string guitar).
-#' \code{fret} is from lowest to highest pitch strings, e.g., strings six
-#' through one.
+#' This function uses a vector of fret integers (`NA` for muted string) to
+#' define a chord, in conjunction with a string `tuning` (defaults to standard
+#' tuning, six-string guitar). `fret` is from lowest to highest pitch strings,
+#' e.g., strings six through one.
 #'
-#' The \code{id} is passed directly to the output. It represents the type of
-#' chord and should conform to accepted \code{tabr} notation. See \code{id}
-#' column in \code{guitar Chords} for examples.
+#' The `id` is passed directly to the output. It represents the type of chord
+#' and should conform to accepted `tabr` notation. See `id` column in
+#' `guitarChords` for examples.
 #'
-#' Note that the \code{semitones} column gives semitone intervals between chord
+#' Note that the `semitones` column gives semitone intervals between chord
 #' notes. These count from zero as the lowest pitch based on the tuning of the
 #' instrument, e.g., zero is E2 with standard guitar tuning. To convert these
 #' semitone intervals to standard semitone values assigned to pitches, use
-#' e.g., \code{pitch_semitones("e2")} (40) if that is the lowest pitch and add
+#' e.g., `pitch_semitones("e2")` (40) if that is the lowest pitch and add
 #' that value to the instrument semitone interval values.
 #' This is the explanation, but doing this is not necessary. You can use
-#' \code{\link{chord_semitones}} to compute semitones directly on pitches in a
+#' [chord_semitones()] to compute semitones directly on pitches in a
 #' chord.
 #'
 #' @param fret integer vector defining fretted chord. See details.
 #' @param id character, the chord type. See details.
-#' @param optional \code{NA} when all notes required. Otherwise an integer
-#' vector giving the indices of\code{fret} that are considered optional notes
+#' @param optional `NA` when all notes required. Otherwise an integer
+#' vector giving the indices of`fret` that are considered optional notes
 #' for the chord.
-#' @param tuning character, string tuning. See \code{tunings} for predefined
-#' tunings. Custom tunings are specified with a similar \code{value} string.
-#' @param ... additional arguments passed to \code{transpose}.
+#' @param tuning character, string tuning. See `tunings` for predefined
+#' tunings. Custom tunings are specified with a similar `value` string.
+#' @param ... additional arguments passed to `transpose()`.
 #'
 #' @return a data frame
 #' @export
@@ -114,19 +113,19 @@ chord_def <- function(fret, id, optional = NA, tuning = "standard", ...){
 #'
 #' Obtain LilyPond quasi-chord notation.
 #'
-#' These functions take a \code{tabr} syntax representation of a chord name and
+#' These functions take a `tabr` syntax representation of a chord name and
 #' convert it to quasi-LilyPond syntax;
-#' "quasi" because the result still uses \code{_} for flats and \code{#} for
-#' sharps, whereas LilyPond itself uses \code{es} and \code{is} (mostly).
-#' This is the format used by \code{tabr} functions involved in communicating
-#' with LilyPond for music transcription, and they make these final conversions
-#' on the fly.
-#' This can be overridden with \code{exact = TRUE}.
+#' "quasi" because the result still uses `_` for flats and `#` for sharps,
+#' whereas LilyPond itself uses `es` and `is` (mostly).
+#' This is the format used by `tabr` functions involved in communicating with
+#' LilyPond for music transcription, and they make these final conversions on
+#' the fly.
+#' This can be overridden with `exact = TRUE`.
 #'
 #' @param root character, root note.
-#' @param chord character, \code{tabr} format chord name.
+#' @param chord character, `tabr` format chord name.
 #' @param exact logical, return a more exact LilyPond chord representation.
-#' @param ... additional arguments passed to \code{transpose}.
+#' @param ... additional arguments passed to `transpose()`.
 #'
 #' @return character
 #' @export
@@ -198,34 +197,31 @@ lp_chord_mod <- function(root, chord, exact = FALSE, ...){
 #' These functions assist with mapping between different information that
 #' define chords.
 #'
-#' For \code{gc_is_known}, a check is done against chords in the
-#' \code{guitarChords} dataset.
-#' A simple noteworthy string is permitted, but any single-note entry will
-#' automatically yield a \code{FALSE} result.
+#' For `gc_is_known()`, a check is done against chords in the `guitarChords`
+#' dataset. A simple noteworthy string is permitted, but any single-note entry
+#' will automatically yield a `FALSE` result.
 #'
-#' \code{gc_info} returns a tibble data frame containing complete information
-#' for the subset of predefined guitar chords specified by \code{name} and
-#' \code{key}.
-#' Any accidentals present in the chord root of \code{name} (but not in the
-#' chord modifier, e.g., \code{m7_5} or \code{m7#5}) are converted according to
-#' \code{key} if necessary.
-#' \code{gc_notes} and \code{gc_fretboard} are wrappers around \code{gc_info},
-#' which return noteworthy strings of chord notes and a named vector of
-#' LilyPond fretboard diagram data, respectively.
+#' `gc_info()` returns a tibble data frame containing complete information for
+#' the subset of predefined guitar chords specified by `name` and `key`.
+#' Any accidentals present in the chord root of `name` (but not in the chord
+#' modifier, e.g., `m7_5` or `m7#5`) are converted according to `key` if
+#' necessary.
+#' `gc_notes()` and `gc_fretboard()` are wrappers around `gc_info()`, which
+#' return noteworthy strings of chord notes and a named vector of LilyPond
+#' fretboard diagram data, respectively.
 #' Note that although the input to these functions can contain multiple chord
 #' names, whether as a vector or as a single space-delimited string, the result
 #' is not intended to be of equal length.
-#' These functions filter \code{guitarChords}. The result is the set of all
+#' These functions filter `guitarChords`. The result is the set of all
 #' chords matched by the supplied input filters.
 #'
-#' \code{gc_name_split} splits a vector or space-delimited set of chord
-#' names into a tibble data frame containing separate chord root and chord
-#' modifier columns.
-#' \code{gc_name_root} and \code{gc_name_mod} are wrappers around this.
+#' `gc_name_split()` splits a vector or space-delimited set of chord names into
+#' a tibble data frame containing separate chord root and chord modifier columns.
+#' `gc_name_root()` and `gc_name_mod()` are wrappers around this.
 #'
 #' @param notes character, a noteworthy string.
-#' @param name character, chord name in \code{tabr} format, e.g.,
-#' \code{"bM b_m b_m7#5"}, etc.
+#' @param name character, chord name in `tabr` format, e.g., `"bM b_m b_m7#5"`,
+#' etc.
 #' @param root_octave integer, optional filter for chords whose root note is in
 #' a set of octave numbers. May be a vector.
 #' @param root_fret integer, optional filter for chords whose root note matches
@@ -234,11 +230,11 @@ lp_chord_mod <- function(root, chord, exact = FALSE, ...){
 #' or above a specific fret. May be a vector.
 #' @param bass_string integer, optional filter for chords whose lowest pitch
 #' string matches a specific string, 6, 5, or 4. May be a vector.
-#' @param open logical, optional filter for open and movable chords. \code{NULL}
+#' @param open logical, optional filter for open and movable chords. `NULL`
 #' retains both types.
 #' @param key character, key signature, used to enforce type of accidentals.
-#' @param ignore_octave logical, if \code{TRUE}, functions like \code{gc_info}
-#' and \code{gc_fretboard} return more results.
+#' @param ignore_octave logical, if `TRUE`, functions like `gc_info()` and
+#' `gc_fretboard()` return more results.
 #'
 #' @return various, see details regarding each function.
 #' @export

R/chords.R

@@ -1,11 +1,11 @@
 #' Chord inversion
 #'
-#' This function inverts a single chord given as a character string.
-#' If \code{n = 0}, \code{chord} is returned immediately.
-#' Otherwise, the notes of the chord are inverted. If \code{abs(n)} is greater
-#' than the number of inversions (excluding root position), an error is thrown.
+#' This function inverts a single chord given as a character string. If `n = 0`,
+#' `chord` is returned immediately. Otherwise, the notes of the chord are
+#' inverted. If `abs(n)` is greater than the number of inversions (excluding
+#' root position), an error is thrown.
 #'
-#' Note that \code{chord_invert} has no knowledge of whether a chord might be
+#' Note that `chord_invert()` has no knowledge of whether a chord might be
 #' considered as in root position or some inversion already, as informed by a
 #' key signature, chord name or user's intent.
 #' This function simply inverts what it receives, treating any defined chord
@@ -20,7 +20,7 @@
 #' having the highest pitch.
 #' The second lowest note becomes the lowest. It's octave does not change.
 #' This pattern is repeated for higher order inversions. The opposite happens
-#' if \code{n} is negative.
+#' if `n` is negative.
 #'
 #' The procedure ensures that the resulting inverted chord is still defined by
 #' notes of increasing pitch.
@@ -76,15 +76,15 @@ chord_invert <- function(chord, n = 0, limit = FALSE){
 #'
 #' Create an arpeggio from a chord.
 #'
-#' This function is based on \code{chord_invert}. If \code{n = 0} then
-#' \code{chord} is returned immediately; other arguments are ignored.
+#' This function is based on `chord_invert`. If `n = 0` then `chord` is returned
+#' immediately; other arguments are ignored.
 #'
 #' @param chord character, a single chord.
 #' @param n integer, number of steps, negative indicates reverse direction
 #' (decreasing pitch).
-#' @param by whether each of the \code{n} steps refers to individual notes in
-#' the chord (an inversion) or raising the entire chord in its given position
-#' by one octave.
+#' @param by whether each of the `n` steps refers to individual notes in the
+#' chord (an inversion) or raising the entire chord in its given position by one
+#' octave.
 #' @param broken logical, return result as an arpeggio of broken chords.
 #' @param collapse logical, collapse result into a single string ready for
 #' phrase construction.
@@ -141,26 +141,26 @@ chord_break <- function(notes){
 #'
 #' Construct a dyad given one note, an interval, and a direction.
 #'
-#' The \code{interval} may be specified by semitones of by common interval name
+#' The `interval` may be specified by semitones of by common interval name
 #' or abbreviation. See examples.
 #' For a complete list of valid interval names and abbreviations see
-#' \code{\link{mainIntervals}}.
-#' \code{key} enforces the use of sharps or flats. This function is based on
-#' \code{transpose}.
-#' \code{notes} and \code{interval} may be vectors, but must be equal length.
+#' [mainIntervals()].
+#' `key` enforces the use of sharps or flats. This function is based on
+#' `transpose()`.
+#' `notes` and `interval` may be vectors, but must be equal length.
 #' Recycling occurs only if one argument is scalar.
 #'
 #' @param notes character, a noteworthy string, single notes only, no chords.
-#' Number of timesteps must equal the length of \code{interval}.
+#' Number of timesteps must equal the length of `interval`.
 #' @param interval integer or character vector; semitones or interval ID,
 #' respectively. See details.
 #' @param reverse logical, reverse the transposition direction. Useful when
-#' \code{interval} is character.
-#' @param octaves,accidentals,key See \code{\link{transpose}}.
+#' `interval` is character.
+#' @param octaves,accidentals,key See [transpose()].
 #'
 #' @return character
 #' @export
-#' @seealso \code{\link{mainIntervals}}
+#' @seealso [mainIntervals()]
 #'
 #' @examples
 #' dyad("a", 4)
@@ -218,7 +218,7 @@ dyad <- function(notes, interval, reverse = FALSE,
 #' @param pitch character, how ranking of chords is determined; lowest pitch,
 #' mean pitch, or highest pitch.
 #' @param decreasing logical, sort in decreasing order.
-#' @param ... additional arguments passed to \code{rank} or \code{order}.
+#' @param ... additional arguments passed to `rank()` or `order()`.
 #'
 #' @return integer for rank and order, character for sort
 #' @export
@@ -273,9 +273,8 @@ chord_sort <- function(notes, pitch = c("min", "mean", "max"),
 #' simplify them.
 #' They operate based only on ordered pitches.
 #'
-#' For \code{chord_slice}, any entry that is empty after slicing is dropped.
-#' An error is thrown is \code{index} is completely out of bounds for all
-#' chords.
+#' For `chord_slice()`, any entry that is empty after slicing is dropped. An
+#' error is thrown is `index` is completely out of bounds for all chords.
 #'
 #' @param notes character, a noteworthy string.
 #' @param index integer, the order of a note in a chord by pitch (not scale
@@ -349,8 +348,8 @@ chord_slice <- function(notes, index){
 #' are sorted by pitch.
 #'
 #' In several cases including single notes or no major or minor third interval
-#' present, \code{NA} is returned.
-#' \code{TRUE} or \code{FALSE} is only returned if such an interval is present.
+#' present, `NA` is returned.
+#' `TRUE` or `FALSE` is only returned if such an interval is present.
 #' If more than one is present, it is based on the lowest in pitch.
 #' It prioritizes major/minor and minor/major adjacent intervals (recognizing a
 #' common triad). If these do not occur adjacent, the lowest third is selected.
@@ -413,25 +412,25 @@ chord_is_minor <- function(notes){
 
 #' Chord constructors
 #'
-#' These functions construct basic chord string notation from root \code{notes}.
+#' These functions construct basic chord string notation from root `notes`.
 #'
-#' Providing a \code{key} signature is used only to ensure flats or sharps for
+#' Providing a `key` signature is used only to ensure flats or sharps for
 #' accidentals.
-#' An additional set of aliases with efficient names, of the
-#' form \code{x*} where \code{*} is a chord modifier abbreviation, is provided
-#' to complement the set of \code{chord_*} functions.
+#' An additional set of aliases with efficient names, of the form `x*` where `*`
+#' is a chord modifier abbreviation, is provided to complement the set of
+#' `chord_*` functions.
 #'
 #' These functions create standard chords, not the multi-octave spanning types
 #' of chords commonly played on guitar.
 #'
 #' @param notes character, a noteworthy string of chord root notes.
 #' @param key key signature. See details.
-#' @param octaves character, passed to \code{transpose}.
+#' @param octaves character, passed to `transpose()`.
 #'
 #' @return character
 #' @export
 #' @name chords
-#' @seealso \code{\link{transpose}}
+#' @seealso [transpose()]
 #'
 #' @examples
 #' chord_min("d")
@@ -653,8 +652,6 @@ chord_maj13 <- function(notes, key = "c", octaves = "tick"){
   .asnw(x)
 }
 
-# lintr will catch function name casing violation # nolint start
-
 #' @export
 #' @rdname chords
 xm <- chord_min
@@ -770,5 +767,3 @@ xm13 <- chord_min13
 #' @export
 #' @rdname chords
 xM13 <- chord_maj13
-
-# nolint end