See 6137 and 6138.

First release:

• usethis::use_cran_comments()
• Update (aspirational) install instructions in README
• Proofread Title: and Description:
• Check that all exported functions have @return and @examples
• Check that Authors@R: includes a copyright holder (role 'cph')
• Check licensing of included files
• Review https://github.com/DavisVaughan/extrachecks

Prepare for release:

• devtools::build_readme()
• urlchecker::url_check()
• devtools::check(remote = TRUE, manual = TRUE)
• devtools::check_win_devel()
• rhub::check_for_cran()
• git push

Submit to CRAN:

• usethis::use_version('minor')
• devtools::submit_cran()
• Approve email

Wait for CRAN...

• Accepted 🎉
• usethis::use_github_release()
• usethis::use_dev_version()

aut <- Plume$new(encyclopedists)
aut$set_main_contributors(writing = c(3, 4))
aut$get_plume() |> 
  dplyr::select(id, role) |> 
  tidyr::unnest(role)
#> # A tibble: 8 × 3
#>      id role                     contributor_rank
#>   <int> <chr>                               <int>
#> 1     1 Supervision                            NA
#> 2     1 Writing - original draft               NA
#> 3     2 <NA>                                   NA
#> 4     2 Writing - original draft               NA
#> 5     3 <NA>                                   NA
#> 6     3 Writing - original draft               NA
#> 7     4 Supervision                            NA
#> 8     4 Writing - original draft               NA

This is because the method will name each vector element dynamically in this case.

Currently, initials are made using the first character of each name. Considering two authors named Zip Zap and Zap Zop, the initials will be the same (Z.Z.) in the contribution list.

In such a case, it's recommended to use $get_contributions(literal_names = TRUE) to avoid any confusion.

I could also implement a way to distinguish the initials of authors using multiple characters from family names when the use of literal names is not an option. E.g., Zip Zap and Zap Zop could be initialised as Z.Za. and Z.Zo..

Prepare for release:

• git pull
• Check current CRAN check results
• Polish NEWS
• devtools::build_readme()
• urlchecker::url_check()
• Update cran-comments.md

Submit to CRAN:

• usethis::use_version('minor')
• devtools::check(remote = TRUE, manual = TRUE)
• devtools::check_win_devel()
• devtools::submit_cran()
• Approve email
• Accepted 🎉

Finish up:

• usethis::use_github_release()
• usethis::use_dev_version()

Quarto added 3 new YAML keys to affiliations, namely isni, ringgold and ror. More details on the Front Matter page.

See r-lib/withr#256. withr::local_tempfile() may not have been working as you intended, and definitely no longer works under {withr} 3.0.0 (when executed in certain ways):

I confirmed this by running:

devtools::check_examples(document = FALSE)

The linked issue cites a few ways to proceed, you can choose which is most appealing to you.

Currently, $get_author_list(format = "") throws an error. It would make more sense to make it return author names instead.

Prepare for release:

• git pull
• Check current CRAN check results
• Polish NEWS
• devtools::build_readme()
• urlchecker::url_check()
• devtools::check(remote = TRUE, manual = TRUE)
• devtools::check_win_devel()
• Update cran-comments.md
• git push

Submit to CRAN:

• usethis::use_version('patch')
• devtools::submit_cran()
• Approve email

Wait for CRAN...

• Accepted 🎉
• git push
• usethis::use_github_release()
• usethis::use_dev_version()
• git push

The example on the readme, and plume::encyclopedists is using the old style of author contribution.

Is it possible to allow numbers other than 1 in the role to allow for ranking the contributions?

Is it possible to internationalise the role names (visualisation vs. visualization), and allow ad hoc contributions?

Prepare for release:

• git pull
• Check current CRAN check results
• Polish NEWS
• urlchecker::url_check()
• devtools::build_readme()
• devtools::check(remote = TRUE, manual = TRUE)
• devtools::check_win_devel()
• git push

Submit to CRAN:

• usethis::use_version('patch')
• devtools::submit_cran()
• Approve email

Wait for CRAN...

• Accepted 🎉
• usethis::use_github_release()
• usethis::use_dev_version(push = TRUE)

As an alternative to contribution lists. E.g.:

Diagram from https://elifesciences.org/articles/63711.

Quarto handles author contributions via the roles key that wasn't documented before. See the new front matter page.

I should implement that feature in PlumeQuarto. This implies the following:

• The only remaining useful methods inherited from Plume relate to setting author's status.
• These methods could then be put in a parent class that both Plume and PlumeQuarto inherit.
• The job of Plume and PlumeQuarto is now more distinct.
• The only job of PlumeQuarto is now to push author data into YAML headers.
• plm_push() is no longer needed and can be removed.

Prepare for release:

• git pull
• Check current CRAN check results
• Polish NEWS
• devtools::build_readme()
• urlchecker::url_check()
• devtools::check(remote = TRUE, manual = TRUE)
• devtools::check_win_devel()
• Update cran-comments.md
• git push

Submit to CRAN:

• usethis::use_version('patch')
• devtools::submit_cran()
• Approve email

Wait for CRAN...

• Accepted 🎉
• git push
• usethis::use_github_release()
• usethis::use_dev_version()
• git push

Currently, to_yaml() output logical values as yes/no which is no longer supported as of YAML 1.2.

Prepare for release:

• git pull
• Check current CRAN check results
• Polish NEWS
• devtools::build_readme()
• urlchecker::url_check()
• devtools::check(remote = TRUE, manual = TRUE)
• devtools::check_win_devel()
• Update cran-comments.md
• git push

Submit to CRAN:

• usethis::use_version('patch')
• devtools::submit_cran()
• Approve email

Wait for CRAN...

• Accepted 🎉
• usethis::use_github_release()
• usethis::use_dev_version()
• git push

while the original author order should be preserved.

aut <- Plume$new(encyclopedists)
aut$get_contributions(roles_first = FALSE, by_author = TRUE)
#> D.D.: Supervision and Writing - original draft
#> J.L.R.d'A.: Supervision and Writing - original draft
#> J.-J.R.: Writing - original draft
#> F.-M.A.: Writing - original draft

Compare to:

aut <- Plume$new(
  encyclopedists,
  roles = c(supervision = "supervision", writing = "writing")
)
aut$get_contributions(roles_first = FALSE, by_author = TRUE)
#> D.D.: supervision and writing
#> J.-J.R.: writing
#> F.-M.A.: writing
#> J.L.R.d'A.: supervision and writing

Currently, plume handles phone numbers via the variable number and pass them to the same attribute in Quarto, which has a different purpose (see quarto-dev/quarto-cli#5860).

I should use phone which is a valid attribute that has mistakenly been omitted in the doc.

Currently, the only ways to set the same main contributors across all but a few roles is to specify main contributors for each roles, or to call set_main_contributors() twice, once to set main contributors across all roles and another time to define main contributors more specifically. E.g.:

aut <- Plume$new(tibble::tibble(
  given_name = LETTERS[1:3],
  family_name = LETTERS[1:3],
  analysis = 1,
  writing = 1,
  methodology = 1,
))
aut$set_main_contributors(3, .roles = aut$get_roles())
aut$set_main_contributors(writing = 2)
aut$get_contributions()
#> Formal analysis: C.C., A.A. and B.B.
#> Methodology: C.C., A.A. and B.B.
#> Writing - original draft: B.B., A.A. and C.C.

I could combine these features so that .roles only applies to unnamed expressions while named expressions would work as normal:

# set the third author as main contributor to all roles but writing
aut$set_main_contributors(3, writing = 2, .roles = aut$get_roles())

Currently, the only way to use custom roles is to pass roles as character strings for every contributor which is error prone and not very flexible.

A better way would be to pass roles via a (named) vector. Contributors would be assigned roles using the same data structure as for CRediT roles.

data
#> # A tibble: 2 × 4
#>   given_name family_name analysis writing
#>   <chr>      <chr>          <dbl>   <dbl>
#> 1 Zip        Zap                1       1
#> 2 Ric        Rac               NA       1

Plume$new(
  data,
  roles = c(
    analysis = "performed the analyses",
    writing = "wrote the manuscript"
  )
)

Keys in the vector identify column names while values are the actual roles to be used.

Rewriting YAML headers slightly alter some data unrelated to authors:

lines <- "
  foo: !!float 123
  # a comment that will be dropped
  bar: >
    Lorem ipsum
    Vivamus quis
  baz: &id1
    a: 1
    b: 2
  boz: *id1
"

yaml::yaml.load(lines) |> 
  yaml::as.yaml() |> 
  cat()
#> foo: 123.0
#> bar: |
#>   Lorem ipsum Vivamus quis
#> baz:
#>   a: 1
#>   b: 2
#> boz:
#>   a: 1
#>   b: 2

This might not be desirable… I could detect these cases, write author data in an empty YAML header at the beginning of the document if they exist, and notify the user about it.

E.g. $set_contribution_degrees() which would have 2 purposes:

• Support Quarto's degree of contribution in PlumeQuarto.
• Give more control on how to order authors when using $get_contributions() for Plume. For example, authors set as lead contributors would be listed first for a given role. Replaced with #34.
• Set contribution degrees to build contribution diagrams in Plume. See #35.

Currently, it's possible to pass multiple roles to one column:

Plume$new(tibble::tibble(
  given_name = c("Zip", "Ric"),
  family_name = c("Zap", "Rac"),
  role = c("a", "b"),
))

This will cause issues when assigning the degrees of contribution (#14) and shouldn't be allowed.