Rdpack/0000755000175000017500000000000014204025772011613 5ustar nileshnileshRdpack/MD50000644000175000017500000001762214204025772012133 0ustar nileshnileshae70a1b70a27e0592d7bba1017a583c7 *DESCRIPTION cfae7fc0fc113ce7bcf13fa2251ddfe3 *NAMESPACE 64b46a0eca1c1a4695df521b514858fa *NEWS.md 5c7c194cecb76e0046d4387e1b074ab9 *R/RStudio.R d4ba37dd52ea4f3252abca2a3da897af *R/Rdo2Rdf.R ae81a25645f62384220411684b33e8cf *R/alias.R 367b479af08d33b2afb9b0d7cb4ad6eb *R/bib.R bfe06e3d7f729a5614b0ba6fdc30fcfe *R/elements.R 3e80ba9e806acef2fc33f8db6e840964 *R/f_usage.R 95eb0f8cc5558175fc9e567c957ad7ba *R/inspect.R fea6530f38874362b59f1c95bc281116 *R/manip.R 03a854cd43c90c99bb3ca5d58b329f49 *R/parse.R b9e4ce86d15977df259070a58545e889 *R/predefined.R 41b3623cb4e992c23c3871dd269ffaa6 *R/promptSexpr.R abd60f89dfacc7bcc33a018b1c1858ff *R/repromptAny.R 2f75ab377508f37bf57e06d300c8917c *R/runexamples.R 5735fe2d04a7a730872a94786ce2ac2a *R/sections.R 2341d017a688b8470b0ccfef0418eed0 *R/signature.R 4b03c8cfbf7a632aca417756f7ef766e *R/slots.R 085eaf35d4daaa9cbab28dada4062251 *R/threedots.R b4d36330bf64cddf616d79b126677a8e *R/usage.R 7a35e91aa982372631ca464d89ef63fc *R/utils.R dc4224cb43cc6669175bde3108e3d6e3 *R/yytransient.R d8633d2ee54a7ab6f53a9897dc6a324a *README.md 22553d86a8f6e60512539a649a90138b *build/partial.rdb fdfddb08f2b9105a7550a1674c5be6c9 *build/vignette.rds 66a9427385ed8ff5c7c9d66429aa1d17 *inst/CITATION bbd543ea42df21639b1819fcda383bf8 *inst/REFERENCES.bib 66d8527ef38edbb31efd9f926c2db3da *inst/RStudio/addins.dcf 0e5181e1cc2c12c1fdee921645eb4637 *inst/auto/REFERENCES.el b3664fa8732f29504b77b9d7dde881eb *inst/doc/Inserting_bibtex_references.R 96b5dfac3c798de4e3cf40030e1a64b7 *inst/doc/Inserting_bibtex_references.Rnw ece3734d91e7cc07631502da1679e714 *inst/doc/Inserting_bibtex_references.pdf 65531fadaff311cac822edd83fcbae4f *inst/doc/Inserting_figures_and_evaluated_examples.R fd416bcea3135e6f78ea79cf0d315533 *inst/doc/Inserting_figures_and_evaluated_examples.Rnw 6cb1fae8283fcbde0709bd747d67bd81 *inst/doc/Inserting_figures_and_evaluated_examples.pdf 933b5a32e8f91fc64fe3c812954f5f6f *inst/examples/Rdpack-package.Rd b122f5d3b5d8026264e902577f3fe840 *inst/examples/RdpackTester.pdf 37133c96d536676dae244c529c92d11b *inst/examples/RdpackTester/DESCRIPTION 8b54e5a89fbda3af5e077053d40bec76 *inst/examples/RdpackTester/NAMESPACE 8cc805ac5647942289b069e8d41450dd *inst/examples/RdpackTester/R/RdpackTester-internal.R 931ea4caaececc9b6c9afc61838ed68c *inst/examples/RdpackTester/inst/REFERENCES.bib 03b2bae7d202852767095d0fa61aa526 *inst/examples/RdpackTester/inst/auto/REFERENCES.el 2b757f55152a6264e97e6f004232caf5 *inst/examples/RdpackTester/man/RdpackTester-package.Rd db800015ba2282ec1e36c49316fd9cc0 *inst/examples/journal_with_percents.bib e745d512aa7b30cd2a4fc63dc506e20b *inst/examples/reprompt.Rd e8ac73c2782b741df4665121db17b036 *inst/examples/tz.Rd 622b071bcbb4e3124bedfe8507e9046a *inst/examples/url_with_percents.bib 3ce861b41014cb5f5a0f36efa1695703 *man/RStudio_reprompt.Rd ce5ffdb9202ee9ceb957937ce58caf9c *man/Rd_combo.Rd 0d6b7f6829f85cd59a480d4d029d38c7 *man/Rdapply.Rd 14248e56a1bc53fca2ebc3c82590563b *man/Rdo2Rdf.Rd 2f632e1addaf24df60161cce2d1952ec *man/Rdo_append_argument.Rd 109ada7043a5af057fc5f979833917a7 *man/Rdo_collect_metadata.Rd db377e52ed67dac64fe3ba0368b98cd0 *man/Rdo_empty_sections.Rd 4095fa1ff964ff1eb168a854517727b8 *man/Rdo_fetch.Rd a6ef0c7c48e1b9e4752ceeab0106a046 *man/Rdo_flatinsert.Rd d8144fe53d234d3f7d3f0b3302388eac *man/Rdo_get_argument_names.Rd c519543d648e6df2e422ba2a84ad40b1 *man/Rdo_get_insert_pos.Rd c7afcccdf050cec02aa58447b77bd42a *man/Rdo_get_item_labels.Rd ba691cf053490c91e2a602e704ab6aea *man/Rdo_insert.Rd c2cd1db2705344dd653c0a95893b5c9d *man/Rdo_insert_element.Rd 774cff52e02f2f1526de1e1cc9368fd9 *man/Rdo_is_newline.Rd 4bf76fc9f2b7ae6e62655adfd9ce0d8f *man/Rdo_locate.Rd ecc69e8592337dac7ac3f5ec25eb7ee6 *man/Rdo_locate_leaves.Rd 8f2670e3fe48eb7a042516feb2c31b48 *man/Rdo_macro.Rd 2b51182cd8e4881e3f91263846a7bf77 *man/Rdo_modify.Rd 20a38d61ada82b7c8f50a74ed4f42dd6 *man/Rdo_modify_simple.Rd a7fbf7b0931cfa1a9ecba847f4b6213e *man/Rdo_piecetag.Rd 0bafc9f685261c4c60de5b08a5384a16 *man/Rdo_remove_srcref.Rd 4c126c04463313e680e2dba38863ef4c *man/Rdo_reparse.Rd 5c18d0067046f8c16bec8d2243324964 *man/Rdo_sections.Rd c8eeb761a98d71d7783a83b6d3cf5292 *man/Rdo_set_section.Rd 4d73366a002b9115fc42f3e8f7f95408 *man/Rdo_show.Rd 6e8cfa5234bd29a601daabb172907235 *man/Rdo_tag.Rd 2e6a44748c5507523abc3a66e238f095 *man/Rdo_tags.Rd 02bf3e062c7a016fbb0e57b4264a6d0c *man/Rdo_which.Rd 933b5a32e8f91fc64fe3c812954f5f6f *man/Rdpack-package.Rd 2b52255cada6c60ad076f58a78df6474 *man/Rdpack_bibstyles.Rd 738ef3d5d5951fac76d384c7c7fb2cbf *man/Rdreplace_section.Rd 326506d2c3f9ec1c27d188d93bdf5419 *man/S4formals.Rd d673a08cd551a2e38669a385a1aaf775 *man/append_to_Rd_list.Rd fc7e74a850a3ad6bc8366a4e891eae96 *man/c_Rd.Rd 00e5d6675bbe5bb984361786ae54b361 *man/char2Rdpiece.Rd 197fcb0865331981c7da01765a26786d *man/compare_usage1.Rd 678fad1297c39010dac194e2f653fcd8 *man/deparse_usage.Rd ea64043157fd2165732a69739a588021 *man/ereprompt.Rd 788bac58a666d58081e3f6ef64046d99 *man/format_funusage.Rd 44e99b8b5f282ce83d7ff96318450d31 *man/get_bibentries.Rd 16cd0305de086216c38a33557644404c *man/get_sig_text.Rd 95ef0eb8e847562637859da515b8e094 *man/get_usage_text.Rd a510b5f840bb0864a14a6a29fc2b4524 *man/insert_all_ref.Rd 15d168a6a59f69a4ca96ca0121f9cd5c *man/insert_citeOnly.Rd 9812a007416aa05a433f61368244040e *man/insert_ref.Rd 952f0b8c2d93c748f06fc89d9c26d0b8 *man/inspect_Rd.Rd a7eb7002a64c5843cb52a0d4cad297c7 *man/inspect_args.Rd 74870e0195d62d2d93d1d7a51063bebd *man/inspect_signatures.Rd 315b02a7da8bfa3d315311a3d3e9bc25 *man/inspect_slots.Rd 86c5b735a5ee57bfc66aa959c903b392 *man/inspect_usage.Rd 0e840f06ba0488b45c399619d06fadf3 *man/list_Rd.Rd dcd6b7ce7d827e83e08fa714d883c043 *man/macros/refmacros.Rd 0e83966b45528f8ff418fbee5b94e3f7 *man/makeVignetteReference.Rd 0dc7b50269710a091b4b952db4488a0b *man/parse_Rdname.Rd edb0d052a7b6ee35d51696e269f98374 *man/parse_Rdpiece.Rd e750cb7e5453d2c0d333a0cd472ab81e *man/parse_Rdtext.Rd c6d300c58087a5bf50549317bffd6a36 *man/parse_pairlist.Rd 3b064ca8778b0aa86290d7578896d652 *man/parse_text.Rd a1b2f57e1a1f9b27f156c9db254e9e8f *man/parse_usage_text.Rd ff558a413dd5b8af3e4c2ec7327181a3 *man/predefined.Rd b2cea461095dd10b405d25593717fd92 *man/promptPackageSexpr.Rd adfd5433985dc6278935b774a8e9cb9d *man/promptUsage.Rd 0a3d93f1f4ef6890772d4399e0f40b69 *man/rdo_text_restore.Rd fade6ed3bdb261e336df91ccfa539cd4 *man/rebib.Rd e745d512aa7b30cd2a4fc63dc506e20b *man/reprompt.Rd 218364e0bfb6022833ef51bfede377d8 *man/set_Rdpack_bibstyle.Rd d884e588e0f5adaf4778ce19b2cc3d31 *man/update_aliases_tmp.Rd b8672aadfcadd035a62d3b824cf51dbb *man/viewRd.Rd d7fcfcf5e3b4d6e025ea1fa0eb9275a9 *man/zzasym_compare.Rd a13a20109cc06181254b976aa58c7dfe *man/zzbsdup.Rd 0a20af2e97069ded300b0a6ca1025c06 *man/zzcapture_promptany.Rd 260b1f23bf3620a4d47b0b06e2aed04c *tests/testthat.R 4ee1a4e0ec700abbd3510cdcef27c9d4 *tests/testthat/StructureClasses.Rd 482b6cfb7dc6eda13e6a8188256985ce *tests/testthat/as.character.f_usage.Rd a62c0ada2058937d01c0979c411a746c *tests/testthat/char2Rdpiece_a.RDS 2ed49593b0fc0c3c100e32d0240a98ba *tests/testthat/char2Rdpiece_b.RDS 8956358852e44bd8b1a7958831487987 *tests/testthat/char2Rdpiece_c.RDS 5881b171c52fd2b7d252642820c903c1 *tests/testthat/classRepresentation-class.Rd af46fe05c6a34fa8a80ee2b0bd297cb3 *tests/testthat/get_sig_text_f1.RDS 916988d6d5aed8c8213ff37afbfa52da *tests/testthat/get_sig_text_f4.RDS 8a87231ae8836fe780151589ed85cb8c *tests/testthat/initialize-methods.Rd 16839eae5c3ca7e5a445704fc2eee8a4 *tests/testthat/myshow-methods.Rd 91c3ffcbddc02b20a13b8e252bb93630 *tests/testthat/show.Rd fb313c1285ab5de1567f031083236e60 *tests/testthat/test-bib.R 1a70e90cdbf147bdca609908935ef369 *tests/testthat/test-char2Rdpiece.R 8471aa81ec63015eb6a26ec43d9cb969 *tests/testthat/test-reprompt.R 96b5dfac3c798de4e3cf40030e1a64b7 *vignettes/Inserting_bibtex_references.Rnw a6fc801c0e7d6067600649635bc6b3d9 *vignettes/Inserting_bibtex_references.org fd416bcea3135e6f78ea79cf0d315533 *vignettes/Inserting_figures_and_evaluated_examples.Rnw 5d83f7c05daee4fddd8aa45521dbf378 *vignettes/Inserting_figures_and_evaluated_examples.org Rdpack/NEWS.md0000644000175000017500000005177614200042571012721 0ustar nileshnilesh# Rdpack 2.1.3.9000 - Rdmacro `\insertCite` gets a new feature allowing to drop parentheses for parenthesised citations, analogous to natbib's `\citealp` in latex. This makes it possible to use markup around the citations outside the arguments of the macro. This provides a workaround github issue #23 by @ms609. - updated vignette "Inserting_bibtex_references" and other documentation. - the pkgdown site now has a `Search` button on the navigation bar. # Rdpack 2.1.3 (CRAN) - fixed a test that was failing with versions of rbibutils before v2.1.1 (issue reported by Andreas Tille). - if the version of rbibutils is greater than v2.2.5, parsing bib files with `rbibutils::readBib` now uses `texChars = "Rdpack"`. This ensures proper rendering of `\'i' in references (by converting `\'i` to `\'\i` which base R renders correctly). For detailed discussion of this see issue GeoBosh/bibutils#7 and NEWS.md in rbibutils v2.2.4 and v2.2.5. # Rdpack 2.1.2 (CRAN) - Rdmacros generating references now drop the `URL` field if a `doi` field generating the same URL is present. This avoids repetition of the URL since rendering the `doi` field produces the URL anyway. - now references with identical authors are sorted by year. - fixed rebib() to process doi's properly. - now checks on github (using github actions) are done on the three major platforms for the following versions of R: release, devel, oldrel, and 3.3. - now a warning (rather than error) is issued if package 'testthat' is not available for tests. - now bibtex files are parsed with option `direct = TRUE` when the version of `rbibutils` is >= ‘2.1.2’. This fixes GeoBosh/rbibutils#3 for Rdpack users (although that needs fixing also for `direct = FALSE`). # Rdpack 2.1.1 (CRAN) - In `viewRd`, the default for the help type now is `options("help_type")` (previously the default was `"text"`). - for `roxygen2` users, added a note in README and `Rdpack-package.Rd` not to indent by exactly four spaces `\insertAllCited{}` relative to `@references` when markdown mode is activated. This is to avoid it being translated by `roxygen2` as verbatim (`\preformatted`) text, see issue (#18). - moved package `gbRd` to Suggests. - fixed uses of \dots in several examples (necessitated by a change in R-devel circa February 2021). # Rdpack 2.1 (CRAN) - dramatic speed up of processing of bibliography references, most noticeable for users with large number of help pages and large `REFERENCES.bib`. (prompted by Kisung You, issue #17) - amended the warning message from bibliography macros to mention duplicated keys. - added entry for `rbibutils` in REFERENCES.bib. - corrected wrong citation of `rbibutils`. # Rdpack 2.0 (CRAN) - removed `bibtex` from `Suggests` and elsewhere. # Rdpack 1.1.0 - imported `rbibutils` and made suitable adjustments to the code. - moved `bibtex` to `Suggests` (since `bibtex` has been orphaned for several years). # Rdpack 1.0.1 - removed a documentation link to a function in `gbutils`, which is not among the dependencies of `Rdpack`. This was raising a NOTE on one of the CRAN testing machines. # Rdpack 1.0.0 (CRAN) - `viewRd()` now loads also Rd macros declared by the package to which the rendered Rd file belongs. Previously only macros from `Rdpack` were loaded but now there is at least one other package, `mathjaxr`, which defines Rd macros. - moved `grDevices` to `Suggests`. - edited some documentation files. # Rdpack 0.11-1 (CRAN) - in documentation of S4 classes, such as `"classname-class.Rd"`, `reprompt()` was sometimes inserting entries for slots already listed in the Slots section. The same bug was causing the new slots not to be reported properly to the user. - in some cases `reprompt()` failed to process properly `\S4method` entries in the Usage section of Rd files. Now fixed. - `reprompt()` now handles `\S4method` statements for replacement methods. As for other functions and methods (S3 and S4), it is sufficient to put a declaration with empty argument list in the Usage section and `reprompt()` will insert the correct formal arguments for the method (they may be different from those of the generic). - `reprompt()` now gives a more helpful error message when `type` is invalid. - corrected some minor typo's in the documentation. - README and the documentation of `reprompt()` and `Rdpack-package` now give more details on `reprompt()`ing replacement functions. - README.md and README.org now give the correct `install.packages` instruction for CRAN (pull request #10 from @katrinleinweber). - some examples were leaving a stray file, `dummyfun.Rd`, after `R CMD check`. # Rdpack 0.11-0 (CRAN) - Updated the vignette about `\insertFig`, `\printExample` and `\runExamples`, to reflect the lifting in `R 3.6.0` of some limitations of Rd processing in previous R versions. - Vignette 'Inserting BibTeX references' now includes a section on bibliography styles. This section was previously only in README. - The fix in Rdpack 0.10-3 (see below) for an issue introduced in R-devel in Oct 2018 will be made permanent, at least for now. This fix resolves also a similar issue in package `pkgdown`, see the discussion at https://github.com/GeoBosh/Rdpack/issues/9 for details and further links. # Rdpack 0.10-3 * fixed issue#9 (reported by by @aravind-j) appearing when a package is built with R-devel (since about Oct 2018) causing references by `\insertAllCited{}` to appear in a single paragraph in the `html` rendering of the Rd documentation. # Rdpack 0.10-2 * added pkgdown site to DESCRIPTION. * README and the vignette about evaluated examples now state that R-devel no longer gives warnings about `\Sexpr` not being a top level section. This means that macro `runExamples` which creates section 'Examples' containing code and results of evaluation will be useable in CRAN packages. * new function `Rdo_fetch()` gets the Rd object representing a help page from an installed or source package. It works also for packages under devtool's developer's mode * The site created with pkgdown contains fewer errors now. (Note that the documentation builds without error with R's tools). * Started moving tests from my local setup to testthat. # Rdpack 0.10-1 (CRAN) * removed redundant references from REFERENCES.bib (they were leftovers from testing). # Rdpack 0.10-0 * updated vignette 'Inserting_bibtex_references'. # Rdpack 0.9-1 * now `REFERENCES.bib` is read-in using the declared encoding for the corresponding package. If there is no declared encoding, "UTF-8" is assumed. * Now macros `\insertCite` and `\insertCiteOnly` use the correct `results=rd` instead of `results=Rd`. This was not catched by `R`s building tools but caused errors when processed with `pkgdown::build_site()`. Fixes issue#8. Also fixes r-lib/pkgdown#784. Thanks to [Jay Hesselberth](https://github.com/jayhesselberth) for uncovering this. * now references produced by the citation macros for BibTeX entries of type `@book` and `@incollection` treat field 'series' similarly to other BibTeX styles, including JSS (issue#7 raised by Kisung You). Note that even though the underlying base R tools are based on JSS, they treat this field differently. * Bugfix: now Rd macro `\printExample` evaluates the expressions in the correct environment. * help page of `get_usage` gets a fairly complete Details section with numerous evaluated examples. * now `run_examples()` escapes `%` by default, before returning the text. This is needed for text that is to be included in an Rd file. It can be turned off by setting the new argument `escape` to `FALSE`. * now `reprompt()` gives a more informative error message if an Rd file describes a non-existent S4 class. This is not captured by `R`s tools. It can happen during development if a class is removed. * now reports printed by `reprompt()` about methods documented in Usage sections, but no longer existing, are more readable. This is due to a new print method for (the mostly internal) class "f_usage". * Many features of Rdpack are best demonstrated on a package. The new package RdpackTester under `./inst/examples` now makes this easier. * now the help page "predefined.Rd" does not print some tables twice in the pdf manual. (This was due to using `\if{latex}{}{}' instead of `\ifelse{latex}{}{}' for those tables.) * also in "predefined.Rd", removed illegal use of vertical bars (in column specifications of tabular environments) from the pure LaTeX code in the `\ifelse` clause(s) and wrapped them in `\out{}`. * in "get_sig_text.Rd", replace `help()` with `utils::help()` to avoid warnings from more stringent `R CMD check`. Similarly, in "Rdpack-package.Rd" replace `packageDescription()` with `utils::packageDescription()`. This may be needed in `\Sexpr`'s more generally (__TODO:__ check if these would still be needed if the symbols are imported by the package.) # Rdpack 0.9-0 (CRAN) * some brush-up of the documentation for the changes since version 0.8-0 of the package. # Rdpack 0.8-4 * now simple mathematics in BibTeX entries is rendered natively, no need to replace dollars with `\eqn{}`. # Rdpack 0.8-3 * new macro `\printExample` for inclusion of example computations in narrative sections, such as `Details`. The code is evaluated and printed similarly to `R` sessions but the code is not prefixed and the output is prefixed with comment symbols, eg. ``` 2+2 ##: 4 ``` * new experimental macro `\runExamples` for use as top level section in an Rd file as a replacement of section `\examples`. `\runExamples{code}` evaluates the code and creates section `\examples` containing the code and the results (similarly to `\printExample`). So, `\runExamples{2 + 2}` produces ``` \examples{ 2 + 2 ##: 4 } ``` The generated section `examples` is processed by R's documentation tools (almost) as if it was there from the outset. * new experimental macro `\insertFig` to create a figure with `R` code and include it in the documentation. The related macro `\makeFig` just creates a graphics file, which can be included with the standard Rd command `\figure`. * new vignette gives a brief description of the new macros. # Rdpack 0.8-2 * Now text citations use "et al." when there are three or more authors. (Issue#6 reported by Timothy P. Bilton) # Rdpack 0.8-1 * in this file, added backticks to `\insertRef` and `\insertAllCited` (see below) - in the rendered `News` on CRAN the backslashed words had disappeared. # Rdpack 0.8-0 (CRAN) * `\insertRef` and `\insertAllCited` macros now support `bibstyles` for formatting references (feature requested by Jamie Halliday, issue#5). Use `Rdpack (>= 0.8)` in `Imports:` to use this feature. Currently only long author names are supported but complete support for styles can be added trivially if requested. * updates to the documentation, in particular the bulk of Rdpack-package.Rd was from 2011! # Rdpack 0.7-1 * improvements to handling of free form citations in textual mode: * (bugfix) now the whole citation is not parenthesised in textual mode, * the handling for textual mode was incomplete in that additional text after the citation was not put inside the parentheses along with the year. * updates to the documentation. * fix a bug in `Rdo_locate_core_section()`. # Rdpack 0.7-0 (CRAN) * consolidated the changes introduced since the previous CRAN release of Rdpack (it was 0.5-5) in preparation for the next release. Users of the new macros for citation can use `Rdpack (>=0.7)` in the `Imports:` field of file "DESCRIPTION" to ensure that they are available. * comprehensive overhaul of handling of errors and warnings during processing of references and citations. In particular, such errors should (in most cases) produce only warnings during `R CMD build` and `R CMD INSTALL`, and not prevent the package from being built and installed. * Unresolved BibTeX keys produce warnings during building and installation of the package, but not errors. Dummy entries are inserted in the documentation explaining what was amiss (currently with 'author' A Adummy). # Rdpack 0.6-x * new Rd macros for citations * `\insertCite` inserts citation(s) for one or more keys and records the keys for `\insertAllCited` (see below). * `\insertCiteOnly` is similar to `\insertCite` but does not record the keys. * `\insertNoCite` records the keys but does not produce a citation. * `\insertAllCited` prints a bibliography including all references recorded by `\insertCite` and `\insertNoCite`. * new entries in this file will use markdown syntax. * updates to the documentation. # Rdpack 0.5-7 * `get_bibentries()` gets a new argument "everywhere". When is is TRUE, the default, unescaped percents are escaped in all bibtex fields, otherwise the replacement is done only in field "URL". * removed several `print()` statements which were accidentally left in the code in v. 0.5-6. * updated help page of `get_bibentries()` and included examples. * cleaned up the imports in NAMESPACE. # Rdpack 0.5-6 * `insert_ref()` and Rd macro `\insertRef` should now work ok in the presence of percent encoded symbols in URL field of a BibTeX entry. Closes issue "Unexpected END_OF_INPUT error (URL parsing?)", see [Rdpack issue 3](https://github.com/GeoBosh/Rdpack/issues/3), raised by [jdnewmil](https://github.com/jdnewmil). * `get_bibentries()` now takes care of percent encoded symbols in URLs. It now returns an object from class "bibentryRd", which inherits from "bibentry" but has its own print method which escapes or unescapes the percent signs in URLs depending on the requested output style. This was also reported by by [jdnewmil](https://github.com/jdnewmil) in issue#3 referenced above. * `get_bibentries()` now tries to load the `bib` file from the development directory of argument "package", in case it is in development mode under "devtools". (Even though the search is with `system.file()`, which `devtools` replaces with its own version, the bib file still needs to be looked for in "inst/", i.e. it is not in the root directory as is the case in installed packages.) # Rdpack 0.5-5 (CRAN) * Streamlined the help page of `reprompt()` and `Rdpack-package`. * new argument, `edit', in `reprompt()` opens the Rd file after updating it. * new function `ereprompt()` (`e' for _edit_)* opens `reprompt()` with suitable defaults to replace the original Rd file and open it in an editor, otherwise equivalent to `reprompt()`. * now if `infile` does not exist, `reprompt()`, and hence `ereprompt()`, strips the directory part, finds the root of the package directory, and looks for the file under `man/` (this uses package `rprojroot`'). In particular, if the working directory is anywhere under the package root, `infile` can be simply the name of the Rd file, without path. * now README.md is generated from README.org. I changed the layout and amended the information in it. * README.* now get links to [georgisemacs](https://github.com/GeoBosh/georgisemacs) for an emacs function to `reprompt()` the Rd file at point. * `viewRd()` now works also when the file is from a package under devtools' development mode on any platform (e.g. RStudio, Emacs/ESS, Rgui). # Rdpack 0.5-4.9000 * new RStudio add-in 'Reprompt`, contributed by Duncan Murdoch. If the file being edited in the code editor is an Rd file it calls `reprompt()`. If the file is as R source file, it looks for the help page of a selected object name and works on it if found, otherwise creates one. # Rdpack 0.5-4 * added the version of `Rdpack` to the abstract of the vignette. This seems more informative than giving the compilation date. * now `reprompt()` doesn't give spurious warnings about unknown Rd macros when the Rd file contains user defined Rd macros. These warnings were harmless and rare, but alarming and annoying. * fixed a bug in `inspect_args()` which caused the warning _"In is.na(x) : is.na() applied to non-(list or vector) of type 'NULL'"_ in `reprompt()`, when the signature of a function in "Usage" section was empty. # Rdpack 0.5-3 (CRAN) * The warning message about a missing reference key now appears also in the respective help page. # Rdpack 0.5-2 * added the github url to DESCRIPTION. * now give a more informative warning if a key is missing from REFERENCES.bib (thanks to Kisung You for suggesting this). # Rdpack 0.5-1 (CRAN) * an example was not restoring the working directory. # Rdpack 0.5-0 * moved gbRd from Depends to Imports and adjusted some examples to use `tools::parse_Rd()` rather than `parse_Rd()` (before this was not necessary since 'gbRd' _depended on_ 'tools'). # Rdpack 0.4-23 * new function `viewRd()` parses and shows an Rd file in a source package. May be particularly helpful for devtools developers. * revamped the vignette, added additional explanations of possible issues. * new functions `makeVignetteReference()` and `vigbib()` generate Bibtex references for vignettes in a package. # Rdpack 0.4-22 (CRAN) * Added the requirement to **Import Rdpack** to the help page of `insert_ref()`. (It was out of sync with the vignette.) * Updated Description in DESCRIPTION, which was also out of sync with the vignette. * Bug fix in the vignette: changed `\@references` to `@references` in the roxygen2 example. # Rdpack 0.4-21 (CRAN) * Edited and amended vignette _"Inserting_bibtex_references"_, including: * additional explanation and an example, * requirement to import Rdpack and a mention of travis etc. * paragraph about devtools. * changed the URL for parse_Rd.pdf in REFERENCES.bib to https. # Rdpack 0.4-20 (CRAN) * cleaned up some minor CRAN issues. # Rdpack 0.4-19 * new facility for inserting references from BibTeX files - just put the line: RdMacros: Rdpack in the `DESCRIPTION` file of your package and the references in `inst/REFERENCES.bib`. Then put `\inserRef{key}{yourpackage}` in documentation chunks to insert item `key` from the bib file. This works with both manually created Rd files and roxygen comments, see the documentation for details. # Rdpack 0.4-18 (CRAN) * from now on, put (CRAN) next to versions published on CRAN (as above) * a minor correction in file NEWS. # Rdpack 0.4-17 * In file DESCRIPTION, changed reprompt and rebib to `reprompt()` and `rebib()`. # Rdpack 0.4-16 * don't export `parse_text` * corrected bug in reprompt for S4 classes - new slots were not handled correctly (see `slots.R` for details). * reprompt for S4 methods* if the methods documentation describes methods that do not exist, print an informative message for the user. (Such methods are also printed for debugging purposes but in non-user friendly form.) - included `methods` in `Imports:` - around R-devel version 2015-07-01 r68620 not including it triggers warnings) # Rdpack 0.4-8 * new functions `.whichtageq` and `.whichtagin`; replaced most calls to `toolsdotdotdotRdTags` with these. * removed `toolsdotdotdotRdTags` # Rdpack 0.4-7 * removed `:::` calls from code; copied some functions from `tools` to achieve this (see "threedots.R"). Renamed the functions replacing `:::` with dotdotdot. * export by name (not the generic export pattern); preparation for more selective export of functions in the future. * new functions: `Rdo_get_argument_names`, `Rdo_get_item_labels` # Rdpack 0.4-5 * dependence `bibtex` becomes "Imports". `tools` and `gbRd` remain (for now) "Depends" since functions from them are used in some examples without `require()`'s. * `rebib()`: now `outfile=""` can be used to request overwriting `infile`. (a small convenience; before the change, one could do this by giving the `outfile` and `infile` the same values.) * Bug fix: `predefined.Rd` contained `\tabular` environments with vertical bars, `|`, in the format specification. This is not documented in "Writing R exts" but works for LaTeX and remained unnoticed by me and R CMD check. However, rendering the help page for the objects documented in "predefined.Rd" gave an error in html and text mode. Package installation failed only if html was requested at build time. * small changes in the documentation # Rdpack 0.4-1 * new major feature: processing references from Bibtex files. The top user level function is `rebib()`, which updates section "references" in an Rd file. `promptPackageSexpr()` has been updated to use this feature. `inspect_Rdbib()` can be used in programming. * new auxiliary functions for work with `bibentry` objects. * new convenience programming functions for Rd objects. * some small bug fixes. * some gaps in the documentation filled. # Rdpack 0.3-11 * `reprompt()` was not handling properly S4 replacement methods. Changed the parsing of the arguments to rectify this. Some other functions also needed correction to handle this. # Rdpack 0.3-10 * `Depends` field in DESCRIPTION file updated to require R 2.15.0 or later. (because of a few uses of `paste0()` in recent code.) # Rdpack 0.3-8 (CRAN) * first public version Rdpack/DESCRIPTION0000644000175000017500000000304214204025772013320 0ustar nileshnileshPackage: Rdpack Type: Package Title: Update and Manipulate Rd Documentation Objects Version: 2.1.4 Date: 2022-02-18 Authors@R: c( person(given = c("Georgi", "N."), family = "Boshnakov", role = c("aut", "cre"), email = "georgi.boshnakov@manchester.ac.uk"), person(given = "Duncan", family = "Murdoch", role = "ctb", email = "murdoch.duncan@gmail.com") ) Description: Functions for manipulation of R documentation objects, including functions reprompt() and ereprompt() for updating 'Rd' documentation for functions, methods and classes; 'Rd' macros for citations and import of references from 'bibtex' files for use in 'Rd' files and 'roxygen2' comments; 'Rd' macros for evaluating and inserting snippets of 'R' code and the results of its evaluation or creating graphics on the fly; and many functions for manipulation of references and Rd files. URL: https://geobosh.github.io/Rdpack/ (website), https://github.com/GeoBosh/Rdpack (devel) BugReports: https://github.com/GeoBosh/Rdpack/issues Depends: R (>= 2.15.0), methods Imports: tools, utils, rbibutils (>= 1.3) Suggests: grDevices, testthat, rstudioapi, rprojroot, gbRd License: GPL (>= 2) LazyLoad: yes RoxygenNote: 7.1.1 NeedsCompilation: no Packaged: 2022-02-18 09:43:01 UTC; georgi Author: Georgi N. Boshnakov [aut, cre], Duncan Murdoch [ctb] Maintainer: Georgi N. Boshnakov Repository: CRAN Date/Publication: 2022-02-18 23:30:02 UTC Rdpack/README.md0000644000175000017500000005373114200422134013070 0ustar nileshnilesh [![CRANStatusBadge](http://www.r-pkg.org/badges/version/Rdpack)](https://cran.r-project.org/package=Rdpack) [![CRAN RStudio mirror downloads](https://cranlogs.r-pkg.org/badges/Rdpack)](https://www.r-pkg.org/pkg/Rdpack) [![CRAN RStudio mirror downloads](https://cranlogs.r-pkg.org/badges/grand-total/Rdpack?color=blue)](https://r-pkg.org/pkg/Rdpack) [![R-CMD-check](https://github.com/GeoBosh/Rdpack/workflows/R-CMD-check/badge.svg)](https://github.com/GeoBosh/Rdpack/actions) [![DOI](https://zenodo.org/badge/100482670.svg)](https://zenodo.org/badge/latestdoi/100482670) Rdpack provides functions for manipulation of R documentation objects, including functions `reprompt()` and `ereprompt()` for updating existing Rd documentation for functions, methods and classes; Rd macros for citations and import of references from `bibtex` files for use in `Rd` files and `roxygen2` comments (`\insertRef`, `\insertCite`, `\insertAllCited`); Rd macros for evaluating and inserting snippets of R code and the results of its evaluation (`\printExample`) or creating graphics on the fly (`\insertFig`); and many functions for manipulation of references and Rd files. # Table of Contents 1. [Installing Rdpack](#orgf584c04) 2. [Inserting Bibtex references and citations](#orgf30ad1f) 1. [Preparation](#org80c11b1) 2. [Inserting references](#org897b48d) 3. [Inserting citations](#orgb9f6370) 4. [Changing the style of references](#org1b75b58) 5. [Troubleshooting](#orgd2f96f4) 1. [A puzzling message in devtools development mode](#org66b8dba) 2. [Typical errors](#orgad19cb1) 6. [Latex markup in BibTeX entries](#org5de9f59) 7. [Encoding of file REFERENCES.bib](#org2c6587a) 3. [Viewing Rd files](#orgb3ff34b) 4. [Using Rdpack::reprompt()](#orgf51067b) 1. [What it does](#orge33c662) 2. [Reprompt and open in an editor](#org77a357c) 5. [Inserting evaluated examples](#orgf18a03b) 1. [Evaluating the examples in section Examples](#orgd535d8a) 6. [Inserting figures/graphs/plots](#org77efc36) # Installing Rdpack Install the [latest stable version](https://cran.r-project.org/package=Rdpack) from CRAN: install.packages("Rdpack") You can also install the [development version](https://github.com/GeoBosh/Rdpack) of `Rdpack` from Github: library(devtools) install_github("GeoBosh/Rdpack") # Inserting Bibtex references and citations The simplest way to insert Bibtex references is with the Rd macro `\insertRef`. Just put `\insertRef{key}{package}` in the documentation to insert item with key `key` from file `REFERENCES.bib` in your package `package`. Alternatively, use one or more `\insertCite{key}{package}` commands to cite works from `REFERENCES.bib`, then issue a single `\insertAllCited{}` directive to produce a list of all cited references. For this to work the `DESCRIPTION` file of the package needs to be amended, see below the full details. ## Preparation To prepare a package for importing BibTeX references it is necessary to tell the package management tools that package Rdpack and its Rd macros are needed. The references should be put in file `inst/REFERENCES.bib`. These steps are enumerated below in somewhat more detail, see also the vignette [`Inserting_bibtex_references`](https://cran.r-project.org/package=Rdpack). 1. Add the following lines to file "DESCRIPTION": Imports: Rdpack RdMacros: Rdpack Make sure the capitalisation of `RdMacros:` is as shown. If the field `RdMacros:` is already present, add "Rdpack" to the list on that line. Similarly for field "Imports:". 2. Add the following line to file "NAMESPACE": importFrom(Rdpack,reprompt) The equivalent line for `roxygen2` is #' @importFrom Rdpack reprompt 3. Create file `REFERENCES.bib` in subdirectory `inst/` of your package and put the BibTeX references in it. ## Inserting references Once the steps outlined above are done, references can be inserted in the documentation as \insertRef{key}{package} where `key` is the bibtex key of the reference and `package` is your package. This works in `Rd` files and in `roxygen` documentation chunks. Usually references are put in section `references`. In an `Rd` file this might look something like: \references{ \insertRef{Rdpack:bibtex}{Rdpack} \insertRef{R}{bibtex} } The equivalent `roxygen2` documentation chunk would be: #' @references #' \insertRef{Rpackage:rbibutils}{Rdpack} #' #' \insertRef{R}{bibtex} The first line above inserts the reference with key `Rpackage:rbibutils` in Rdpack's REFERENCES.bib. The second line inserts the reference labeled `R` in file REFERENCES.bib from package `bibtex`. The example above demonstrates that references from other packages can be inserted (in this case `bibtex`), as well. This is strongly discouraged for released versions but is convenient during development. One relatively safe use is when the other package is also yours - this allows authors of multiple packages to not copy the same refences to each of their own packages. For further details see the vignette [`Inserting_bibtex_references`](https://cran.r-project.org/package=Rdpack) or open it from `R`: vignette("Inserting_bibtex_references", package = "Rdpack") (The latest version of the vignette is at [`Inserting_bibtex_references (development version on github)`](https://github.com/GeoBosh/Rdpack/blob/master/vignettes/Inserting_bibtex_references.pdf).) ## Inserting citations Additional Rd macros are available for citations. They also can be used in both Rd and roxygen2 documentation. `\insertCite{key}{package}` cites `key` and records it for use by `\insertAllCited`, see below. `key` can contain more keys separated by commas. `\insertCite{parseRd,Rpackage:rbibutils}{Rdpack}` produces (Murdoch 2010; Boshnakov and Putman 2020) and `\insertCite{Rpackage:rbibutils}{Rdpack}` gives (Boshnakov and Putman 2020). By default the citations are parenthesised: `\insertCite{parseRd}{Rdpack}` produces (Murdoch 2010). To get textual citations, like Murdoch (2010), put the string `;textual` at the end of the key. The references in the last two sentences would be produced with `\insertCite{parseRd}{Rdpack}` and `\insertCite{parseRd;textual}{Rdpack}`, respectively. This also works with several citations, e.g. `\insertCite{parseRd,Rpackage:rbibutils;textual}{Rdpack}` produces: Murdoch (2010); Boshnakov and Putman (2020). The macro `\insertNoCite{key}{package}` records one or more references for `\insertAllCited` but does not cite it. Setting `key` to `*` will include all references from the specified package. For example, `\insertNoCite{R}{bibtex}` and `\insertNoCite{*}{utils}` record the specified references for inclusion by `\insertAllCited`. `\insertAllCited` inserts all references cited with `\insertCite` or `\insertNoCite`. Putting this macro in the references section will keep it up to date automatically. The Rd section may look something like: \insertAllCited{} or, in roxygen2, the references chunk might look like this: #' @references #' \insertAllCited{} Don't align the backslash with the second 'e' of `@references`, since roxygen2 may interpret it as verbatim text, not macro. To mix the citations with other text, such as \`\`see also'' and \`\`chapter 3'', write the list of keys as a free text, starting it with the symbol `@` and prefixing each key with it. The `@` symbol will not appear in the output. For example, the following code \insertCite{@see also @parseRd and @Rpackage:rbibutils}{Rdpack} \insertCite{@see also @parseRd; @Rpackage:rbibutils}{Rdpack} \insertCite{@see also @parseRd and @Rpackage:rbibutils;textual}{Rdpack} produces: (see also Murdoch 2010 and Boshnakov and Putman 2020) (see also Murdoch 2010; Boshnakov and Putman 2020) see also Murdoch (2010) and Boshnakov and Putman (2020) With the parenthesised citations, if you need markup for the text before or after the citations, say `see also` in italic, put `;nobrackets`1 at the end of the first argument of the Rd macro, take out the part containing markup, and put the parentheses were suitable. For example, (\emph{see also} \insertCite{@@parseRd and @Rpackage:rbibutils;nobrackets}{Rdpack}) (in markdown, use `_see also_` in place of `\emph{see also})`. This gives: (*see also* Murdoch 2010 and Boshnakov and Putman 2020) — `\insertCiteOnly{key}{package}` is as `\insertCite` but does not include the key in the list of references for `\insertAllCited`. ## Changing the style of references Bibliography styles for lists of references are supported from Rdpack (>= 0.8). Currently the only alternative offered is to use long names (Georgi N. Boshnakov) in place of the default style (Boshnakov GN). More comprehensive alternatives can be included if needed or requested. To cause all lists of references produced by `\insertAllCited` in a package to appear with full names, add `.onLoad()` function to your package. If you don't have `.onLoad()`, just copy the following definition: .onLoad <- function(lib, pkg){ Rdpack::Rdpack_bibstyles(package = pkg, authors = "LongNames") invisible(NULL) } If you already have `.onLoad()`, add the line containing the `Rdpack::Rdpack_bibstyles` call to it. After installling/reloading your package the lists of references should appear with long author names. "Rdpack" itself now uses this style. ## Troubleshooting ### A puzzling message in devtools development mode The described procedure works transparently in `roxygen2` chunks and with Hadley Wickham's package `devtools`. Packages are built and installed properly with the `devtools` commands and the references are processed as expected. Currently (2017-08-04) if you run help commands `?xxx` for functions from the package you are working on *in developement mode* and their help pages contain references, you may encounter some puzzling warning messages, something like: 1: In tools::parse_Rd(path) : ~/mypackage/man/abcde.Rd: 67: unknown macro '\insertRef' These warnings are harmless and can be ignored — the help pages are built properly and no warnings appear outside *developer's mode*, e.g. in a separate R session2. Even better, use the function `viewRd()` described below to view the required help file. ### Typical errors The functions underlying the processing of references and citations intercept errors, such as missing BibTeX labels or badly formed items in REFERENCES.bib, and issue informative warnings during the building and installation of the package, so that the developer is alerted but the package can still be built and installed. In these cases the functions usually insert a suitable text in the documentation, as well. If you encounter a situation contradicting this description, it is probably a bug — please report it (but check first for the typical errors listed below). A non-decipherable error message is probably caused by one of the following typical errors: - misspelled `RdMacros:` field in file DESCRIPTION. The safest way to avoid this is to copy it from the DESCRIPTION file of a working package. - omitted second argument of a reference or citation macro. Most of these macros have the package name as a second argument. These errors occur during parsing of the Rd files, before the control is passed to the `Rdpack`'s macros. ## Latex markup in BibTeX entries In principle, BibTeX entries may contain arbitrary Latex markup, while the Rd format supports only a subset. As a consequence, some BibTeX entries may need some editing when included in REFERENCES.bib3. Only do this for entries that do not render properly or cause errors, since most of the time this should not be necessary. If mathematics doesn't render properly replace the Latex dollar syntax with Rd's `\eqn`, e.g. `$x^2$` with `\eqn{x^2}`. This should not be needed for versions of Rdpack 0.8-4 or later. Some Latex macros may have to be removed or replaced with suitable Rd markup. Again, do this only if they cause problems, since some are supported, e.g. `\doi`. See also the overview help page, `help("Rdpack-package")`, of package `"Rdpack"`. Among other things, it contains some dummy references which illustrate the above. ## Encoding of file REFERENCES.bib If a package has a declared encoding (in file `DESCRIPTION`), `REFERENCES.bib` is read-in with that encoding4. Otherwise, the encoding of `REFERENCES.bib` is assumed to be UTF-8 (which includes ASCII as a subset). Note that BibTeX entries downloaded from online databases and similar sources may contain unexpected characters in other encodings, e.g. 'latin1'. In such cases the check tools in R-devel (since about 2018-10-01) may give warnings like: prepare_Rd: input string 1 is invalid in this locale To resolve this, convert the file to the declared encoding or UTF-8. Alternatively, replace the offending symbols with their classic TeX/LaTeX equivalents (which are ASCII). Non-ASCII symbols in BibTeX entries obtained from online databases are often in fields like "Abstract", which are normally not included in lists of references and can be deleted from REFERENCES.bib. One way to check for non-ASCII symbols in a file is `tools::showNonASCIIfile()`. Internally, LaTeX sequences standing for accented Latin characters, such as `\'e` and `\"o`, are converted to UTF-8. So, even if the file REFERENCES.bib is pure ASCII, it may implicitly give raise to non-ASCII characters. This may cause R's checking tools to complain about non-ASCII characters even after it has been verified that there are none. If this happens, add the encoding declaration to file DESCRIPTION5: Encoding: UTF-8 Needless to say, make sure that there are really no characters from encodings like 'latin1'. # Viewing Rd files The function `viewRd()` can be used to view Rd files in the source directory of a package6. A typical user call would look something like: Rdpack::viewRd("./man/filename.Rd") The requested help page is shown in the default format for the current R session (taken from `getOption("help_type")`). To request a specific format set `type` to `"html"` or `"text"`, as in: Rdpack::viewRd("./man/filename.Rd", type = "html") # open in a browser Rdpack::viewRd("./man/filename.Rd", type = "text") # text `viewRd()` renders references and citations correctly, since it processes Rd macros. Users of 'devtools' can use `viewRd` in place of `help()` to view rendered Rd sources in development mode. This should work also in development mode on any platform (e.g. RStudio, Emacs/ESS, Rgui)7. # Using Rdpack::reprompt() ## What it does `Rdpack::reprompt()` updates `Rd` documentation. In the most common case when it is called on an `Rd` file, it updates the documentation of all functions, methods and classes documented in the file. For functions this includes updating the usage section, adding missing aliases and `\item`'s for arguments not described yet. For methods and classes entries for new methods and slots are updated in a similar way. See the documentation for details. `Rdpack::reprompt()` can also be invoked on an object or the name of an object, just as `utils::prompt`. In that case it checks for installed documentation for the object and works on it if found. Otherwise it creates an `Rd` file with initial content similar to the one generated by `utils::prompt` but modified so that the package can be built. If a new function, say `newfun` is to be documented in an existing Rd file, just add `newfun()` to the usage section in the file and call `Rdpack::reprompt()` to insert the correct usage statement, add an alias, and add items for any new arguments. Put quotes around the function name if it is non-syntactic. For replacement functions (functions with names ending in `<-`) `reprompt()` will insert the proper usage statement. For example, if the signature of `xxx<-` is `(x, ..., value)`, then both, `"xxx<-"()` and `xxx() <- value` will be replaced by `xxx(x, ...) <- value`. `Rdpack::reprompt()` **does not remove** anything that has become obsolete but it alerts the user to remove aliases, methods, and descriptions of arguments that have been removed. ## Reprompt and open in an editor To open the `reprompt()`-ed file, argument `edit` can be used. For this to work, `options("editor")` needs to be set suitably but it usually is. If `edit = TRUE`, then `Rdpack::reprompt()` will open the Rd file in an editor. For more convenient access to this feature, use `Rdpack::ereprompt()` (edit reprompt), which calls `Rdpack::reprompt()` with `edit = TRUE` and sets the output filename to be the same as the input filename. In RStudio, `reprompt()` can be invoked on the `Rd` file being edited or the selected name of an object in a source code file using RStudio add-in `Repropmpt` (contributed by Duncan Murdoch). Obviously, this makes sense only for Rd files not generated by `roxygen2`. In Emacs/ESS there are various ways to use `Rdpack::reprompt()` and `Rdpack::ereprompt()`. If `options("editor")` is set to `emacsclient`, `Rdpack::ereprompt` is one option. It can also be assigned to a key (wrapped in Elisp code), for example to be invoked on the currently edited file. Such a function and example key binding can be found at [georgisemacs](https://github.com/GeoBosh/georgisemacs). # Inserting evaluated examples `Rdpack` provides a macro that takes a chunk of R code, evaluates it, and includes both the code and the results in the rendered documentation. The layout is similar to that in the R console but the code is not prefixed with anything and the output is prefixed with comment symbols. For example, \printExample{2+2; a <- 2*3; a} gives 2 + 2 ##: 4 a <- 2 * 3 a ##: 6 The help page of `?Rdpack::promptUsage` contains a number of examples created with `\printExample`. The corresponding Rd file can be obtained from the package tarball or from . Vignette [`Inserting_figures_and_evaluated_examples`](https://github.com/GeoBosh/Rdpack/blob/master/vignettes/Inserting_figures_and_evaluated_examples.pdf) gives further details. ## Evaluating the examples in section Examples The macro `\runExamples` can be used as a replacement of section `examples`. For example, if the following code is put at the top level in an Rd file (i.e. not in a section): \runExamples{2+2; a <- 2*3; a} then it will be evaluated and replaced by a normal section examples: \examples{ 2 + 2 ##: 4 a <- 2 * 3 a ##: 6 } This generated examples section is processed by the standard R tools (almost) as if it was there from the outset. In particular, the examples are run by the R's quality control tools and tangled along with examples in other documentation files8. A small example package using this feature is at [runExamplesCheck](https://github.com/GeoBosh/reprexes/tree/master/runExamplesCheck). # Inserting figures/graphs/plots Figures can be inserted with the help of the standard Rd markup command `\figure`. To generate figures on the fly, package `"Rdpack"` provides the Rd macro `\insertFig` which takes a snipped of R code, evaluates it and inserts the plot produced by it (using `\figure`). `\insertFig` takes three arguments: a filename, the package name and the code to evaluate to produce the figure. For example, \insertFig{cars.png}{mypackage}{x <- cars$speed; y <- cars$dist; plot(x,y)} will evaluate the code, save the graph in file `"man/figures/cars.png"` subdirectory of package `"mypackage"`, and include the figure using `\figure`. See vignette [`Inserting_figures_and_evaluated_examples`](https://github.com/GeoBosh/Rdpack/blob/master/vignettes/Inserting_figures_and_evaluated_examples.pdf) for more details. # Footnotes 1 From `Rdpack (> 2.1.3)` (prompted by Martin R. Smith, issue #23). 2 If you care, here is what happens. These warnings appear because `devtools` reroutes the help command to process the developer's Rd sources (rather than the documentation in the installed directory) but doesn't tell `parse_Rd` where to look for additional macros. Indeed, the message above shows that the error is in processing a source Rd file in the development directory of the package and that the call to `parse_Rd` specifies only the file. 3 Thanks to Michael Dewey for suggesting the discussion of this. 4 From `Rdpack (>=0.9-1)` The issue of not handling the encoding was raised by Professor Brian Ripley. 5 Admittedly, this is not ideal since the user should not need to care how things are processed internally but I haven't pinpointed the exact cause for this. 6 From `Rdpack (>= 0.4-23)`. 7 In recent versions of Rstudio this function is no longer needed, since `?fun` now handles the macros. 8 In versions of `R` before `3.6.0` the macro `\runExamples` may cause `R CMD check` to give a warning warning about unknown `\Sexpr` section at top level. Rdpack/man/0000755000175000017500000000000014203665045012370 5ustar nileshnileshRdpack/man/inspect_slots.Rd0000644000175000017500000000107113501141722015536 0ustar nileshnilesh\name{inspect_slots} \alias{inspect_slots} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Inspect the slots of an S4 class } \description{ Inspect the slots of an S4 class. } \usage{ inspect_slots(rdo, final = TRUE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object.} \item{final}{if not TRUE insert text with suggestions, otherwise comment the suggestions out. } } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \keyword{RdoS4} Rdpack/man/rdo_text_restore.Rd0000644000175000017500000000327713501141722016252 0ustar nileshnilesh\name{rdo_text_restore} \alias{rdo_text_restore} %- Also NEED an '\alias' for EACH other topic documented here. \title{Ensure exported fragments of Rd are as the original} \description{ For an Rd object imported from a file, this function ensures that fragments that were not not changed during the editing of the object remain unchanged in the exported file. This function is used by reprompt() to ensure exactly that. } \usage{ rdo_text_restore(cur, orig, pos_list, file) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{cur}{an Rd object} \item{orig}{an Rd object} \item{pos_list}{a list of srcref objects specifying portions of files to replace, see 'Details'.} \item{file}{a file name, essentially a text representation of \verb{cur}.} } \details{ This is essentially internal function. It exists because, in general, it is not possible to restore the original Rd file from the Rd object due to the specifications of the Rd format. The file exported from the parsed Rd file is functionally equivalent to the original but equivalent things for the computer are not necessarily equally pleasant for humans. This function is used by \code{reprompt} when the source is from a file and the option to keep the source of unchanged sections as in the original. \strong{todo:} needs clean up, there are unnecessary arguments in particular. } \value{ the main result is the side effect of replacing sections in \code{file} not changed by \code{reprompt} with the original ones. } \author{ Georgi N. Boshnakov } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{reprompt}} } \keyword{RdoProgramming} Rdpack/man/Rdo_insert.Rd0000644000175000017500000000245513501141722014764 0ustar nileshnilesh\name{Rdo_insert} \alias{Rdo_insert} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Insert a new element in an Rd object possibly surrounding it with new lines } \description{ Insert a new element in an Rd object possibly surrounding it with new lines. } \usage{ Rdo_insert(rdo, val, newline = TRUE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object} \item{val}{the content to insert, an Rd object.} \item{newline}{a logical value, controls the insertion of new lines before and after \code{val}, see `Details'. } } \details{ Argument \code{val} is inserted in \code{rdo} at an appropriate position, see \code{\link{Rdo_get_insert_pos}} for detailed explanation. If \code{newline} is TRUE, newline elements are inserted before and after \code{val} but only if they are not already there. Typically, \code{val} is a section of an Rd object and \code{rdo} is an Rd object which is being constructed or modified. } \value{ an Rd object } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{RdoProgramming} %\keyword{RdoElements} \keyword{RdoBuild} Rdpack/man/zzasym_compare.Rd0000644000175000017500000000326713501141722015721 0ustar nileshnilesh\name{.asym_compare} \alias{.asym_compare} \alias{.ocompare} %- Also NEED an '\alias' for EACH other topic documented here. \title{Tensor comparison and asymmetric comparison between two vectors} \description{Tensor comparison and asymmetric comparison between two vectors.} \usage{ .ocompare(x, y) .asym_compare(x, y) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{x}{ %% ~~Describe \code{x} here~~ } \item{y}{ %% ~~Describe \code{y} here~~ } } \details{ \code{.ocompare} (for "outer compare") returns a matrix whose (i,j)th element is TRUE if x[i] is identical to y[j], and FALSE otherwise. \code{.asym_compare} calls \code{.ocompare} and iterprets its result asymmetrically. Elements of \code{x} that are not in \code{y} ae considered "new". Similarly, Elements of \code{y} that are not in \code{x} ae considered "removed". Elements that are in both are "common". Todo: check if the above is correct or the other way round! !!! } \value{ For \code{.ocompare}, a matrix as described in Details. For \code{.asym_compare} a list with indices as follows. \item{i_new}{new elements, indices in \code{x} of elements that are not in \code{y}.} \item{i_removed}{removed elements, indices in \code{y} of elements that are not in \code{x}.} \item{i_common}{common elements, indices in \code{x} of elements that are in both, \code{x} and \code{y}.} } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ ##---- Should be DIRECTLY executable !! ---- } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{internal} Rdpack/man/get_sig_text.Rd0000644000175000017500000000653214041230036015336 0ustar nileshnilesh\name{get_sig_text} \alias{get_sig_text} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Produce the textual form of the signatures of available methods for an S4 generic function \Sexpr[stage=build,results=hide]{require(Rdpack)} } \description{ Produce the textual form of the signatures of available methods for an S4 generic function. } \usage{ get_sig_text(rdo, package = NULL) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object.} \item{package}{if of class "character", give only methods defined by \code{package}, otherwise give all methods. } } \details{ Signatures are found using function \code{findMethodSignatures} from package "methods". Here we find all methods for \code{show()} defined in package \code{"methods"} and print the first few of them: \printExample{fn <- utils::help("show-methods", package = "methods"); rdo <- utils:::.getHelpFile(fn); head(get_sig_text(rdo))} } \value{ A character vector with one element for each method. } \author{Georgi N. Boshnakov} \note{ todo: It would be better to call promptMethods() to get the signatures but in version R-2.13.x I had trouble with argument `where' (could not figure out how to use it to restrict to functions from a package; also, promptMethods() seemed to call the deprecated function getMethods()). Check how these things stand in current versions of \R, there may be no problem any more (checked, in 2.14-0 it is the same). } %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ ## load another package with some S4 methods ("methods" is already loaded) require("stats4") rdo <- Rdo_fetch("show", package = "methods") ## alternatively: #fn <- help("show-methods", package = "methods") #rdo <- utils:::.getHelpFile(fn) ## this will find all methods for "show" in currently loaded packages ## (print only some of them) head(get_sig_text(rdo)) ## this will select only the ones from package "stats4" get_sig_text(rdo, package = "stats4") ## this is also fine (interactively) but need to choose ## the appropriate element of "fn" if length(fn) > 1 #fn <- help("show-methods") ## this finds nothing #fn <- help("logLik-methods", package = "methods") #fn Rdo_fetch("logLik-methods", package = "methods") ## this does #fn <- help("logLik-methods", package = "stats4") #rdo <- utils:::.getHelpFile(fn) rdo2 <- Rdo_fetch("logLik-methods", package = "stats4") get_sig_text(rdo2) get_sig_text(rdo2, package = "stats4") ## only default method defined ## using this: setGeneric("f1", function(x, y){NULL}) ## since the following gives error in pkgdown: #f1 <- function(x, y){NULL} #setGeneric("f1") fn <- tempfile() reprompt("f1", filename = fn) rdo <- tools::parse_Rd(fn) get_sig_text(rdo) setClass("aRdpack") setClass("bRdpack") ## several methods defined setGeneric("f4", function(x, y){NULL}) setMethod("f4", c("numeric", "numeric"), function(x, y){NULL}) setMethod("f4", c("aRdpack", "numeric"), function(x, y){NULL}) setMethod("f4", c("bRdpack", "numeric"), function(x, y){NULL}) setMethod("f4", c("aRdpack", "bRdpack"), function(x, y){NULL}) reprompt("f4", filename = fn) rdo <- tools::parse_Rd(fn) get_sig_text(rdo) unlink(fn) } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoS4} %\keyword{RdoProgramming} Rdpack/man/Rdo_get_argument_names.Rd0000644000175000017500000000245413501141722017323 0ustar nileshnilesh\name{Rdo_get_argument_names} \alias{Rdo_get_argument_names} %- Also NEED an '\alias' for EACH other topic documented here. \title{Get the names of arguments in usage sections of Rd objects} \description{Get the names of arguments in usage sections of Rd objects.} \usage{ Rdo_get_argument_names(rdo) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rdo object.} } \details{ All arguments names in the "arguments" section of \code{rdo} are extracted. If there is no such section, the results is a character vector of length zero. Arguments which have different descriptions for different OS'es are included and not duplicated. Arguments which have descriptions for a particular OS are included, irrespectively of the OS of the running R process. (\strong{todo:} introduce argument to control this?) } \value{ a character vector } % \references{ % %% ~put references to the literature/web site here ~ % } \author{Georgi N. Boshnakov} % \note{ % %% ~~further notes~~ % } % % %% ~Make other sections like Warning with \section{Warning }{....} ~ % \seealso{ \code{\link{Rdo_get_item_labels}} } \examples{ ##---- Should be DIRECTLY executable !! ---- } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{ ~kwd1 } Rdpack/man/insert_ref.Rd0000644000175000017500000002064314200026644015015 0ustar nileshnilesh\name{insert_ref} \alias{insert_ref} \alias{insertRef} \title{Insert bibtex references in Rd and roxygen2 documentation} \description{ Package Rdpack provides Rd macros for inserting references and citations from bibtex files into R documentation. Function \code{insert_ref()} is the workhorse behind this mechanism. The description given on this page should be sufficient, for more details see the vignette. } \usage{ insert_ref(key, package = NULL, \dots, cached_env = NULL) } \arguments{ \item{key}{the bibtex key of the reference, a character string.} \item{package}{the package in which to look for the bibtex file.} \item{\dots}{ further arguments to pass on to \code{get_bibentries()}. The only one of interest to users is \code{bibfile}, whose default is "REFERENCES.bib", see \code{\link{get_bibentries}}. } \item{cached_env}{ environment, used to avoid repeatedly pasing the bib file from scratch, mainly useful by the Rd macros. } } \details{ \code{insert_ref} extracts a bibliograhic reference from a bibtex file, converts it to Rd format and returns a single string with embedded newline characters. It is the workhorse in the provided mechanism but most users do not even need to know about \code{insert_ref}. Package \pkg{Rdpack} provides several Rd macros for inserting references and citations in the documentation of a package. All macros work in both, manually written Rd files and in \pkg{roxygen2} documentation chunks. The macros look for references in file \code{"REFERENCES.bib"} in the root of the installation directory of the package. When a package is in development mode under \pkg{devtools}, \code{"inst/REFERENCES.bib"} in the development directory of the package is checked first. See also \code{\link{get_bibentries}} but note that while direct calls to \code{insert_ref()} can specify a different file, the filename and the places where it is looked for are fixed for the Rd macros. The description below assumes that \pkg{Rdpack} has been added to file DESCRIPTION, as described in \code{\link{Rdpack-package}} and vignette \code{"Inserting_bibtex_references"}. The Rd macros are put in the text of documentation sources (\sQuote{Rd} files or \sQuote{roxygen2} chunks). \subsection{Rd macro insertRef}{ \verb{\\insertRef{key}{package}} inserts the reference with bibtex key \verb{key} from file \code{"REFERENCES.bib"} in package \verb{package}. Argument \sQuote{package} can be any installed \R package, not necessarily the one of the documentation object, as long as it contains file \code{"REFERENCES.bib"} in the root of its installation directory. The references are partially processed when the package is built. References inserted with \verb{\\insertRef} appear in the place where the macro is put, usually in a dedicated references section (\verb{\\references} in Rd files, \verb{@references} in roxygen chunks). For example, section \sQuote{References} of this help page shows (among other things)) the rendered results of the following lines in the Rd source file: \preformatted{ \\insertRef{Rpackage:rbibutils}{Rdpack} \\insertRef{parseRd}{Rdpack} \\insertRef{bibutils6.10}{rbibutils} } A roxygen2 documentation chunk might look like this: \preformatted{ #' @references #' \\insertRef{Rpackage:rbibutils}{Rdpack} #' #' \\insertRef{parseRd}{Rdpack} #' #' \\insertRef{bibutils6.10}{rbibutils} } The first reference has label \verb{Rpackage:rbibutils} and is taken from file \code{"REFERENCES.bib"} in package \pkg{Rdpack}. The third reference is from the file \code{"REFERENCES.bib"} in package \pkg{rbibutils}. For more details see vignette \code{"Inserting_bibtex_references"}. } \subsection{Rd macro insertCite}{ \code{\\insertCite{key}{package}} cites the key and records it for use by \code{\\insertAllCited}, see below. \code{key} can contain more keys separated by commas. \tabular{lll}{ \code{\\insertCite{parseRd,Rpackage:rbibutils}{Rdpack}} \tab \insertCite{parseRd,Rpackage:rbibutils}{Rdpack} \cr \code{\\insertCite{Rpackage:rbibutils}{Rdpack}} \tab \insertCite{Rpackage:rbibutils}{Rdpack} \cr \code{\\insertCite{bibutils6.10}{rbibutils}} \tab \insertCite{bibutils6.10}{rbibutils} } By default the citations are parenthesised \insertCite{parseRd}{Rdpack}. To get textual citations, like \insertCite{parseRd;textual}{Rdpack}, put the string \code{;textual} at the end of the key. The references in the last two sentences were produced with \code{\\insertCite{parseRd}{Rdpack}} and \code{\\insertCite{parseRd;textual}{Rdpack}}, respectively. This also works with several citations, e.g. \cr \code{\\insertCite{parseRd,Rpackage:rbibutils;textual}{Rdpack}} produces: \insertCite{parseRd,Rpackage:rbibutils;textual}{Rdpack}. To mix the citations with other text, such as \sQuote{see also} and \sQuote{chapter 3}, write the list of keys as free text, starting it with the symbol \code{@} and prefixing each key with it. The \code{@} symbol will not appear in the output. For example, the following code \preformatted{ \insertCite{@see also @parseRd and @Rpackage:rbibutils}{Rdpack}, \insertCite{@see also @parseRd; @Rpackage:rbibutils}{Rdpack}, \insertCite{@see also @parseRd and @Rpackage:rbibutils;textual}{Rdpack}. } produces: \tabular{l}{ \insertCite{@see also @parseRd and @Rpackage:rbibutils}{Rdpack}, \cr \insertCite{@see also @parseRd; @Rpackage:rbibutils}{Rdpack}, \cr \insertCite{@see also @parseRd and @Rpackage:rbibutils;textual}{Rdpack}. } In the parenthesised form, adding \verb{;nobrackets} at the end of the list of keys causes the enclosing parentheses to be dropped. This is useful if you wish to use markup for the text surrounding the references. For example, \preformatted{ (\emph{see also} \insertCite{@@parseRd; @Rpackage:rbibutils;nobrackets}{Rdpack}). } gives: (\emph{see also} \insertCite{@@parseRd; @Rpackage:rbibutils;nobrackets}{Rdpack}). Without \sQuote{\verb{;nobrackets}} the result would be (\emph{see also} \insertCite{@@parseRd; @Rpackage:rbibutils}{Rdpack}). } \subsection{Rd macro insertNoCite}{ The macro \code{\\insertNoCite{key}{package}} records one or more references for \code{\\insertAllCited} but does not cite it. Setting \code{key} to \code{*} will include all references from the specified package. For example, \code{\\insertNoCite{parseRd}{Rdpack}} and \code{\\insertNoCite{*}{rbibutils}} record the specified references for inclusion by \code{\\insertAllCited}. } \subsection{Rd macro insertAllCited}{ \code{\\insertAllCited} inserts all references cited with \code{\\insertCite} and \code{\\insertNoCite}. Putting this macro in the references section will keep the references up to date automatically. The Rd section may look something like: \preformatted{ \\references{ \\insertAllCited{} } } or in roxygen2, the references chunk might look like this: \preformatted{ #' @references #' \\insertAllCited{} } } \subsection{Rd macro insertNoCite}{ \code{\\insertCiteOnly{key}{package}} is as \code{\\insertCite} but does not include the key in the list of references for \code{\\insertAllCited}. } } \value{ for \code{insert_ref}, a character string } \references{ For illustrative purposes there are two sets of citations below The first set of references is obtained with \code{\\insertRef} for each reference: \insertRef{parseRd}{Rdpack} \insertRef{Rpackage:rbibutils}{Rdpack} \insertRef{bibutils6.10}{rbibutils} ---- The following references are obtained with a single \code{\\insertAllCited{}}. The references are sorted automatically by the surnames of the authors: \insertAllCited{} } \author{Georgi N. Boshnakov} \seealso{ \code{\link{Rdpack-package}} for overview, \code{vignette("Inserting_bibtex_references", package = "Rdpack")} for further details on the citation macros \code{\link{insert_citeOnly}} for the function generating citations } \examples{ cat(insert_ref("Rpackage:rbibutils", "Rdpack"), "\n") } \keyword{documentation} \keyword{Rd} Rdpack/man/char2Rdpiece.Rd0000644000175000017500000000370613501141722015147 0ustar nileshnilesh\name{char2Rdpiece} \alias{char2Rdpiece} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Convert a character vector to Rd piece } \description{ Convert a character vector to Rd piece. } \usage{ char2Rdpiece(content, name, force.sec = FALSE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{content}{a character vector.} \item{name}{name of an Rd macro, a string.} \item{force.sec}{TRUE or FALSE, see `Details'.} } \details{ Argument \code{content} is converted to an Rd piece using \code{name} to determine the format of the result. The \verb{Rd tag} of \code{content} is set as appropriate for \code{name}. More specifically, if \code{name} is the name of a macro (without the leading `\verb{\\}') whose content has a known "Rdtag", that tag is used. Otherwise the tag is set to "TEXT". If \code{force.sec} is TRUE, \code{name} is treated as the name of a top level section of an Rd object. A top level section is exported as one argument macro if it is a standard section (detected with \code{\link{is_Rdsecname}}) and as the two argument macro "\verb{\section}" otherwise. If \code{force.sec} is FALSE, the content is exported as one argument macro without further checks. } \author{Georgi N. Boshnakov} \note{ This function does not attempt to escape special symbols like `\%'. } %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ ## add a keyword section a1 <- char2Rdpiece("graphics", "keyword") a1 ## "keyword" is a standard Rd top level section, so 'force.sec' is irrelevant a2 <- char2Rdpiece("graphics", "keyword", force.sec = TRUE) identical(a1, a2) ## an element suitable to be put in a "usage" section char2Rdpiece("log(x, base = exp(1))", "usage") ## a user defined section "Todo" char2Rdpiece("Give more examples for this function.", "Todo", force.sec = TRUE) } %\keyword{RdoProgramming} %\keyword{RdoElements} \keyword{RdoBuild} Rdpack/man/Rdapply.Rd0000644000175000017500000001074113501141722014264 0ustar nileshnilesh\name{Rdapply} \alias{Rdapply} \alias{rattr} \alias{Rdtagapply} \title{Apply a function over an Rd object} \description{Apply a function recursively over an Rd object, similarly to rapply but keeping attributes.} \usage{ Rdapply(x, \dots) Rdtagapply(object, FUN, rdtag, classes = "character", how = "replace", \dots) rattr(x, y) } \arguments{ \item{x}{the Rd object on which to apply a function.} \item{object}{the Rd object on which to apply a function.} \item{FUN}{The function to apply, see details} \item{rdtag}{apply FUN only to elements whose \code{Rd_tag} attribute is \code{rdtag}.} \item{y}{an Rd object with the same structure as \code{x}, see `Details'.} \item{\dots}{arguments to pass to \code{rapply}, see `Details'.} \item{classes}{a character vector, passed on to \code{\link{rapply}}, see `Details'. } \item{how}{a character string, passed on to \code{\link{rapply}}, see `Details'. } } \details{ \code{Rdapply} works like \code{rapply} but preserves the attributes of \code{x} and (recursively) any sublists of it. \code{Rdapply} first calls \code{rapply}, passing all arguments to it. Then it restores recursively the attributes by calling \code{rattr}. Note that the object returned by \code{rapply} is assumed to have identical structure to the original object. This means that argument \code{how} of \code{rapply} must not be "unlist" and normally will be "replace". \code{Rdtagapply} gives sensible default values for \code{classes} and \code{how}. See the documentation of \code{\link{rapply}} for details and the possible choices for \code{classes}, \code{how} or other arguments passed to it via \code{"\dots"}. \code{Rdtagapply} is a convenience variant of \code{Rdapply} for the common task of modifying or examining only elements with a given \code{Rd_tag} attribute. Since the Rd equation macros \verb{\eqn} and \verb{\deqn} are assigned Rd tag "VERB" but are processed differently from other "VERB" pieces, pseudo-tags "mathVERB" and "nonmathVERB" are provided, such that "mathVERB" is for actions on the first argument of the mathematical macros \verb{\eqn} and \verb{\deqn}, while "nonmathVERB" is for actions on "VERB" macros in all other contexts. There is also a pseudo-tag "nonmath" for anything that is not math. \code{rattr} is an auxilliary function which takes two Rd objects (with identical structure) and recursively examines them. It makes the attributes of any lists in the first argument identical to the corresponding attributes in the second. } \value{ For \code{Rdapply} and \code{Rdtagapply}, an Rd object with some of its leaves replaced as specified above. For \code{rattr}, the object \code{x} with attributes of any list elements of it set to the corresponding attributes of \code{y}. } \author{Georgi N. Boshnakov} \note{ todo: may be it is better to rename the argument FUN of \code{Rdtagapply} to \code{f}, which is its name in \code{rapply}. } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{rapply}} } \examples{ # create an Rd object for the sake of example u1 <- list_Rd(name = "Dummyname", alias = "dummyfun", title = "Dummy title", description = "Dummy description", usage = "dummyfun(x)", value = "numeric vector", author = "A. Author", examples = "\na <- matrix(1:6,nrow=2)\na \%*\% t(a)\nt(a) \%*\% a", Rd_class=TRUE ) # correct R code for examples but wrong for saving in Rd files Rdo_show(u1) # escape percents everywhere except in comments # (actually, .anypercent escapes only unescaped percents) rdo <- Rdapply(u1, Rdpack:::.anypercent, classes = "character", how = "replace") # syntactically wrong R code for examples but ok for saving in Rd files Rdo_show(rdo) # Rdo2Rdf does this by default for examples and other R code, # so code can be kept syntactically correct while processing. # (reprompt() takes care of this too as it uses Rdo2Rdf for saving) fn <- tempfile("u1", fileext="Rd") Rdo2Rdf(u1, file = fn) # the saved file contains escaped percents but they disappear in parsing: file.show(fn) Rdo_show(tools::parse_Rd(fn)) # if you think that sections should start on new lines, # the following makes the file a little more human-friendly # (by inserting new lines). \dontshow{# todo: additional arg. for list_Rd for this? } u2 <- Rdpack:::.Rd_tidy(u1) Rdo2Rdf(u2, file = fn) file.show(fn) unlink(fn) } \keyword{RdoProgramming} Rdpack/man/set_Rdpack_bibstyle.Rd0000644000175000017500000000164213501141722016625 0ustar nileshnilesh\name{set_Rdpack_bibstyle} \alias{set_Rdpack_bibstyle} %- Also NEED an '\alias' for EACH other topic documented here. \title{Set up a bibstyle defined in Rdpack} \description{Set up a bibstyle defined in Rdpack} \usage{ set_Rdpack_bibstyle(bibstyle = "JSSRd") } %- maybe also 'usage' for other objects documented here. \arguments{ \item{bibstyle}{a character string} } %\details{ %%% ~~ If necessary, more details than the description above ~~ %} %\value{ %%% ~Describe the value returned %%% If it is a LIST, use %%% \item{comp1 }{Description of 'comp1'} %%% \item{comp2 }{Description of 'comp2'} %%% ... %} %\references{ %%% ~put references to the literature/web site here ~ %} %\author{ %%% ~~who you are~~ %} %\note{ %%% ~~further notes~~ %} % %%% ~Make other sections like Warning with \section{Warning }{....} ~ % %\seealso{ %%% ~~objects to See Also as \code{\link{help}}, ~~~ %} %\examples{ %} \keyword{internal} Rdpack/man/Rdo_insert_element.Rd0000644000175000017500000000251613501141722016473 0ustar nileshnilesh\name{Rdo_insert_element} \alias{Rdo_insert_element} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Insert a new element in an Rd object } \description{ Insert a new element at a given position in an Rd object. } \usage{ Rdo_insert_element(rdo, val, pos) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object} \item{val}{the content to insert.} \item{pos}{position at which to insert \code{val}, typically an integer but may be anything accepted by the operator "[[". } } \details{ \code{val} is inserted at position \code{pos}, between the elements at positions \code{pos-1} and \code{pos}. If \code{pos} is equal to 1, \code{val} is prepended to \code{rdo}. If \code{pos} is missing or equal to the length of \code{rdo}, \code{val} is appended to \code{rdo}. todo: allow vector \code{pos} to insert deeper into the object. todo: character \code{pos} to insert at a position specified by "tag" for example? todo: more guarded copying of attributes? } \value{ an Rd object } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{RdoProgramming} %\keyword{RdoElements} \keyword{RdoBuild} Rdpack/man/zzbsdup.Rd0000644000175000017500000000160713501141722014353 0ustar nileshnilesh\name{.bsdup} \alias{.bsdup} \alias{.bspercent} \alias{.anypercent} %- Also NEED an '\alias' for EACH other topic documented here. \title{Escape backslashes and percent in Rd code} \description{Escape backslashes and percent in Rd code.} \usage{ .bspercent(x) .anypercent(x) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{x}{a character string} } \details{ \code{.bsdup(x)} duplicates backslashes. \code{.bspercent(x)} escapes percent signs. \code{.anypercent(x)} also escapes percent signs but but only if the \code{Rd_tag} attribute of \code{x} is not COMMENT. } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ ##---- Should be DIRECTLY executable !! ---- } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{internal} Rdpack/man/Rdo_sections.Rd0000644000175000017500000000632613501141722015310 0ustar nileshnilesh\name{Rdo_sections} \alias{Rdo_sections} \alias{Rdo_locate_core_section} \title{Locate the sections in Rd objects} \description{Locate the Rd sections in an Rd object and return a list of their positions and names.} \usage{ Rdo_sections(rdo) Rdo_locate_core_section(rdo, sec) } \arguments{ \item{rdo}{an Rd object.} \item{sec}{the name of a section, a character string. For builtin sections the leading backslash should be included.} } \details{ \code{Rdo_sections} locates all sections at the top level in an Rd object. This includes the predefined sections and the user defined sections. Sections wrapped in \verb{#ifdef} directives are also found. \code{Rdo_sections} returns a list with one entry for each section in \code{rdo}. This entry is a list with components \code{"pos"} and \code{"title"} giving the position (suitable for use in \verb{"[["}) and the title of the section. For user defined sections the actual name is returned, not "section". The names of the sections are returned as single strings without attributes. The titles of predefined sections are single words but user defined sections may have longer titles and sometimes contain basic markup. \code{Rdo_locate_core_section} works similarly but returns only the results for section \code{sec}. Currently it simply calls \code{Rdo_sections} and returns only the results for \code{sec}. Note that for consistency \code{Rdo_locate_core_section} does not attempt to simplify the result in the common case when there is only one instance of the requested section---it is put in a list of length one. \insertCite{parseRd}{Rdpack} % only for testing! \insertCite{Rpack:bibtex}{Rdpack} % only for testing! } \value{ A list giving the positions and titles of the sections in \code{rdo} as described in 'Details'. The format is essentially that of \code{\link{Rdo_locate}}, the difference being that field "value" from that function is renamed to "title" here. \item{pos}{the position, a vector of positive integers,} \item{title}{a standard section name, such as \verb{"\\name"} or, in the case of "\\section", the actual title of the section. } } \author{Georgi N. Boshnakov} \note{ I wrote \code{Rdo_sections} and \code{Rdo_locate_core_section} after most of the core functionality was tested. Currently these functions are underused---they can replace a number of internal and exported functions. } \seealso{ \code{\link{Rdo_locate}} } \references{ \insertAllCited{} % only for testing } \examples{ infile <- system.file("examples", "tz.Rd", package = "Rdpack") rd <- tools::parse_Rd(infile) ## Locate all top level sections in rd sections <- Rdo_sections(rd) ## How many sections there are in rd? length(sections) ## What are their titles? sapply(sections, function(x) x$title) ## The names of builtin sections include the backslash Rdo_locate_core_section(rd, "\\\\title") ## Locate a user defined secion Rdo_locate_core_section(rd, "Further information") ## The names of builtin sections include the backslash Rdo_locate_core_section(rd, "\\\\details") ## All appearances of the requested section are returned Rdo_locate_core_section(rd, "\\\\alias") Rdo_locate_core_section(rd, "\\\\keyword") } \keyword{Rd} Rdpack/man/c_Rd.Rd0000644000175000017500000000417413757415153013542 0ustar nileshnilesh\name{c_Rd} \alias{c_Rd} \title{Concatenate Rd objects or pieces} \description{Concatenates Rd objects or pieces} \usage{ c_Rd(...) } \arguments{ \item{\dots}{objects to be concatenated, Rd objects or character strings, see `Details'. } } \details{ The arguments may be a mixture of lists and character strings. The lists are typically "Rd" objects or pieces. The character strings may also be elements of "Rd" objects carrying "Rd_tag" attributes. The "Rd_tag" attribute of character strings for which it is missing is set to "TEXT". Finally, each character element of \code{"\dots"} is enclosed in \code{list}. Eventually all arguments become lists and they are concatenated using \code{c()}. If any of the arguments is of class "Rd", the class of the result is set to "Rd". Otherwise, the "Rd_tag" of the result is set to the first (if any) non-null "Rd_tag" in the arguments. The structure of "Rd" objects is described by \insertCite{parseRd;textual}{Rdpack}. } \value{ An Rd object or a list whose attribute "Rd_tag" is set as descibed in `Details' } \author{Georgi N. Boshnakov} \seealso{ \code{\link{list_Rd}} } \references{ \insertAllCited{} } \examples{ a1 <- char2Rdpiece("Dummyname", "name") a2 <- char2Rdpiece("Dummyallias1", "alias") a3 <- char2Rdpiece("Dummy title", "title") a4 <- char2Rdpiece("Dummy description", "description") ## The following are equivalent ## (gbRd::Rdo_empty() creates an empty list of class 'Rd') if(requireNamespace("gbRd")){ b1 <- c_Rd(gbRd::Rdo_empty(), list(a1), list(a2), list(a3), list(a4)) c1 <- c_Rd(gbRd::Rdo_empty(), list(a1, a2, a3, a4)) d1 <- c_Rd(gbRd::Rdo_empty(), list(a1, a2), list(a3, a4)) identical(c1, b1) identical(c1, d1) Rdo_show(b1) ## insert a newline d1n <- c_Rd(gbRd::Rdo_empty(), list(a1, a2), Rdo_newline(), list(a3, a4)) str(d1n) } ## When most of the arguments are character strings ## the function 'list_Rd' may be more convenient. u1 <- list_Rd(name = "Dummyname", alias = "Dummyallias1", title = "Dummy title", description = "Dummy description", Rd_class = TRUE ) Rdo_show(u1) } \keyword{RdoBuild} %\keyword{RdoProgramming} Rdpack/man/Rdo_reparse.Rd0000644000175000017500000000304214013547521015120 0ustar nileshnilesh\name{Rdo_reparse} \alias{Rdo_reparse} %- Also NEED an '\alias' for EACH other topic documented here. \title{Reparse an Rd object} \description{Reparse an Rd object.} \usage{ Rdo_reparse(rdo) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object} } \details{ \code{Rdo_reparse} saves \code{rdo} to a temporary file and parses it with \code{parse_Rd}. This ensures that the Rd object is a "canonical" one, since one and the same Rd file can be produced by different (but equivalent) Rd objects. Also, the functions in this package do not attend to attribute "srcref" (and do not use it) and reparsing takes care of this. (todo: check if there is a problem if the tempfile disappears.) %insertCite{@see @parseRd,@Rpack:bibtex}{Rdpack} % only for testing! \insertCite{parseRd,Rpack:bibtex}{Rdpack} % only for testing! } \references{ \insertAllCited{} % only for testing } %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ # the following creates Rd object rdo dummyfun <- function(x) x fn <- tempfile("dummyfun", fileext = "Rd") reprompt(dummyfun, filename = fn) rdo <- tools::parse_Rd(fn) dottext <- "further arguments to be passed on." dots <- paste0("\\\\", "dots") rdo2 <- Rdo_append_argument(rdo, dots, dottext, create = TRUE) rdo2 <- Rdo_append_argument(rdo2, "z", "a numeric vector") Rdo_show(Rdo_reparse(rdo2)) # the following does ot show the arguments. (todo: why?) # (see also examples in Rdo_append_argument) Rdo_show(rdo2) unlink(fn) } \keyword{Rd} Rdpack/man/Rdo_locate_leaves.Rd0000644000175000017500000000301313521254557016272 0ustar nileshnilesh\name{Rdo_locate_leaves} \alias{Rdo_locate_leaves} \title{Find leaves of an Rd object using a predicate} \description{Apply a function to the character leaves of an Rd object and return the indices of those for which the result is TRUE.} \usage{ Rdo_locate_leaves(object, f = function(x) TRUE) } \arguments{ \item{object}{the object to be examined, usually a list.} \item{f}{a function (predicate) returning TRUE for elements with the desired property. } } \details{ \code{object} can be any list whose elements are character strings or lists. The structure is examined recursively. If \code{object} is a character vector, it is enclosed in a list. This function provides a convenient way to locate leaves of an Rd object with a particular content. The function is not limited to Rd objects but it assumes that the elements of \code{object} are either lists or charater vectors and currently does not check if this is the case. \strong{todo:} describe the case of \code{list()} (\code{Rd_tag}'ed.) } \value{ a list of the positions of the leaves for which the predicate gives \code{TRUE}. Each position is an integer vector suitable for the \code{"[["} operator. } \author{Georgi N. Boshnakov} \examples{ dummyfun <- function(x) x fn <- tempfile("dummyfun", fileext = "Rd") reprompt(dummyfun, filename = fn) rdo <- tools::parse_Rd(fn) f <- function(x) Rdo_is_newline(x) nl <- Rdo_locate_leaves(rdo, f ) length(nl) # there are quite a few newline leaves! unlink(fn) } %\keyword{Rdlookup} \keyword{Rd} Rdpack/man/ereprompt.Rd0000644000175000017500000000262513501141722014670 0ustar nileshnilesh\name{ereprompt} \alias{ereprompt} \title{Update an Rd file and open it in an editor} \description{ Update an Rd file and open it in an editor. This is a wrapper for reprompt with different defaults for some parameters. } \usage{ ereprompt(..., edit = TRUE, filename = TRUE) } \arguments{ \item{\dots}{ passed on to \code{\link{reprompt}}, see its documentation for details.} \item{edit}{if \code{TRUE}, the default, open an editor when finished.} \item{filename}{if \code{TRUE}, the default, replace and/or edit the original Rd file.} } \details{ \code{ereprompt} calls \code{reprompt} to do the actual job but has different defaults for the arguments described on this page. By default, it replaces the original Rd file with the updated documentation and opens it in an editor. } \value{ called for the side effect of updating Rd documentation file and opening it in an editor } %\references{ %%% ~put references to the literature/web site here ~ %} \author{Georgi N. Boshnakov} %\note{ %%% ~~further notes~~ %} % %%% ~Make other sections like Warning with \section{Warning }{....} ~ % \seealso{ \code{\link{reprompt}} which does the actual work } \examples{ ## this assumes that the current working directory is ## in any subdirectory of the development directory of Rdpack \dontrun{ ereprompt(infile = "reprompt.Rd") } } \keyword{documentation} % use one of RShowDoc("KEYWORDS") Rdpack/man/inspect_args.Rd0000644000175000017500000000321613501141722015331 0ustar nileshnilesh\name{inspect_args} \alias{inspect_args} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Inspect the argument section of an Rd object } \description{ Inspect the argument section of an Rd object. } \usage{ inspect_args(rdo, i_usage) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object describing functions.} \item{i_usage}{see Details.} } \details{ \code{inspect_args} checks if the arguments in the documentation object \code{rdo} match the (union of) the actual arguments of the functions it describes. If \code{i_usage} is missing, it is computed by inspecting the current definitions of the functions described in \code{rdo}, see \code{inspect_usage}. This argument is likely to be supplied if the function calling \code{inspect_args} has already computed it for other purposes. } \value{ TRUE if the arguments in the documentation match the (union of) the actual arguments of the described functions, FALSE otherwise. The returned logical value has attribute `details' which is a list with the following components. \item{rdo_argnames}{arguments described in the documentation object, \code{rdo}.} \item{cur_argnames}{arguments in the current definitions of the described functions.} \item{added_argnames}{new arguments} \item{removed_argnames}{removed (dropped) arguments.} } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{RdoProgramming} \keyword{RdoUsage} %\keyword{RdFunction} Rdpack/man/Rdo_tags.Rd0000644000175000017500000000265413501141722014417 0ustar nileshnilesh\name{Rdo_tags} \alias{Rdo_tags} %- Also NEED an '\alias' for EACH other topic documented here. \title{Give the Rd tags at the top level of an Rd object} \description{Give the Rd tags at the top level of an Rd object.} \usage{ Rdo_tags(rdo, nulltag = "") } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object.} \item{nulltag}{a value to use when \code{Rd_tag} is missing or NULL.} } \details{ The \verb{"Rd_tag"} attributes of the top level elements of \code{rdo} are collected in a character vector. Argument \code{nulltag} is used for elements without that attribute. This guarantees that the result is a character vector. \code{Rdo_tags} is similar to the internal function \code{tools:::RdTags}. Note that \code{tools:::RdTags} may return a list in the rare cases when attribute \code{Rd_tags} is not present in all elements of \code{rdo}. %% ~~ If necessary, more details than the description above ~~ } \value{ a character vector } % \references{ % %% ~put references to the literature/web site here ~ % } \author{Georgi N. Boshnakov} % \note{ % %% ~~further notes~~ % } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{Rdo_which}}, \code{\link{Rdo_which_tag_eq}}, \code{\link{Rdo_which_tag_in}} %% ~~objects to See Also as \code{\link{help}}, ~~~ } \examples{ ##---- Should be DIRECTLY executable !! ---- } \keyword{Rd} Rdpack/man/Rdo_flatinsert.Rd0000644000175000017500000000162613501141722015632 0ustar nileshnilesh\name{Rdo_flatinsert} \alias{Rdo_flatinsert} \alias{Rdo_flatremove} \title{Insert or remove content in an Rd fragment} \description{Insert or remove content in an Rd fragment.} \usage{ Rdo_flatinsert(rdo, val, pos, before = TRUE) Rdo_flatremove(rdo, from, to) } \arguments{ \item{rdo}{an Rd object.} \item{val}{the value to insert.} \item{pos}{position.} \item{before}{if TRUE, insert the new content at pos, pushing the element at pos forward. } \item{from}{beginning of the region to remove.} \item{to}{end of the region to remove.} } \details{ \code{Rdo_flatinsert} inserts \code{val} at position \code{pos}, effectively by concatenation. \code{Rdo_flatremove} removes elements from \code{from} to \code{to}. } \value{ the modified \code{rdo} } \author{Georgi N. Boshnakov} % \seealso{ % %% ~~objects to See Also as \code{\link{help}}, ~~~ % } %\examples{ %} \keyword{ RdoProgramming } Rdpack/man/compare_usage1.Rd0000644000175000017500000000457313501141722015552 0ustar nileshnilesh\name{compare_usage1} \alias{compare_usage1} \title{ Compare usage entries for a function to its actual arguments } \description{ Compare usage entries for a function to its actual arguments. } \usage{ compare_usage1(urdo, ucur) } \arguments{ \item{urdo}{ usage text for a function or S3 method from an Rd object or file. } \item{ucur}{usage generated from the actual object.} } \details{ Compares the usage statements for functions in the Rd object or file \code{urdo} to the usage inferred from the actual definitions of the functions. The comparison is symmetric but the interpretation assumes that \code{ucur} may be more recent. Note: do not compare the return value to TRUE with \code{identical} or \code{isTRUE}. The attribute makes the returned value not identical to TRUE in any case. } \value{ TRUE if the usages are identical, FALSE otherwise. The return value has attribute "details", which is a list providing details of the comparison. The elements of this list should be referred by name, since if one of \code{urdo} or \code{ucur} is NULL or NA, the list contains only the fields "obj_removed", "obj_added", "rdo_usage", "cur_usage", and "alias". \item{identical_names}{a logical value, TRUE if the `name' is the same in both objects.} \item{obj_removed}{names present in \code{urdo} but not in \code{ucur}} \item{obj_added }{names present in \code{ucur} but not in \code{urdo}} \item{identical_argnames }{a logical value, TRUE if the argument names in both objects are the same.} \item{identical_defaults }{a logical value, TRUE if the defaults for the arguments in both objects are the same.} \item{identical_formals }{a logical value, TRUE if the formals are the same, i.e. fields \code{identical_argnames} and \code{identical_defaults} are both TRUE.} \item{added_argnames }{names of arguments in \code{ucur} but not in \code{urdo}.} \item{removed_argnames}{names of arguments in \code{urdo} but not in \code{ucur}.} \item{names_unchanged_defaults }{names of arguments whose defaults are the same.} \item{rdo_usage }{a copy of \code{urdo}.} \item{cur_usage }{a copy of \code{ucur}.} \item{alias }{alias of the name of the object, see `Details'.} } \author{Georgi N. Boshnakov} \seealso{ \code{\link{inspect_usage}} } \keyword{RdoUsage} Rdpack/man/append_to_Rd_list.Rd0000644000175000017500000000433413501141722016303 0ustar nileshnilesh\name{append_to_Rd_list} \alias{append_to_Rd_list} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Add content to the element of an Rd object or fragment at a given position } \description{ Add content to the element of an Rd object or fragment at a given position. } \usage{ append_to_Rd_list(rdo, x, pos) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object} \item{x}{the content to append, an Rd object or a list of Rd objects.} \item{pos}{position at which to append \code{x}, typically an integer but may be anything accepted by the operator "[[". } } \details{ The element of \code{rdo} at position \code{pos} is replaced by its concatenation with \code{x}. The result keeps the "Rd_tag" of \code{rdo[[pos]]}. Argument \code{pos} may specify a position at any depth of the Rd object. This function is relatively low level and is mainly for use by other functions. } \value{ the modified \code{rdo} object } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ #rdoseq <- utils:::.getHelpFile(help("seq")) rdoseq <- Rdo_fetch("seq", "base") iusage <- which(tools:::RdTags(rdoseq) == "\\\\usage") iusage attr(rdoseq[[iusage]], "Rd_tag") ## append a new line after the last usage line rdoseq2 <- append_to_Rd_list(rdoseq, list(Rdo_newline()), iusage) ## Suppose that we wish to describe the function 'sequence' in the same Rd file. ## We append an usage statement for 'sequence()', without worrying about its ## actual signature. rdoseq2 <- append_to_Rd_list(rdoseq2, list(Rdo_Rcode("sequence()")), iusage) Rdo_show(rdoseq2) ## the two operations can be done in one step rdoseq3 <- append_to_Rd_list(rdoseq, list(Rdo_newline(), Rdo_Rcode("sequence()")), iusage) Rdo_show(rdoseq3) ## now run reprompt() to update rdoseq3, namely: ## (1) it corrects the signature of 'sequence' in section \usage. ## (2) reports new argument "nvec" ## (3) inserts \item for the new argument(s) in section \arguments. reprompt(rdoseq3, filename=NA) } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{RdoProgramming} \keyword{RdoBuild} Rdpack/man/RStudio_reprompt.Rd0000644000175000017500000000246213501141722016173 0ustar nileshnilesh\name{RStudio_reprompt} \alias{RStudio_reprompt} \title{Call reprompt based on RStudio editor contents} \description{This function uses the RStudio API to call \code{\link{reprompt}} on either the current help file in the editor, or if a name is highlighted in a \file{.R} file, on that object.} \usage{ RStudio_reprompt(verbose = TRUE) } \arguments{ \item{verbose}{ If \code{TRUE} print progress to console. } } \details{ This function depends on being run in RStudio; it will generate an error if run in other contexts. It depends on code being in a package that has already been built, installed, and attached. In RStudio, this means you should run \dQuote{Install and Restart} before running this function. It is automatically installed into RStudio as an add-in called \dQuote{Reprompt}. Whether invoked directly or through the add-in, it looks at the file currently being edited in the code editor. If it is an \file{.Rd} file, it will run \code{\link{reprompt}} on that file. If it is an \R source file, it will look for a selected object name. It queries the help system to find if there is already a help page for that name, and if so, works on that. If not, it will try to create one. } \value{ \code{NULL}, invisibly. } \author{ Duncan Murdoch } \seealso{ \code{\link{reprompt}}, \code{\link{prompt}} } Rdpack/man/macros/0000755000175000017500000000000013757754040013663 5ustar nileshnileshRdpack/man/macros/refmacros.Rd0000644000175000017500000000410213757754040016130 0ustar nileshnilesh% insert reference #1 - key, #2 - package %% changing to cache bib as insertCite does %% \newcommand{\insertRef}{\Sexpr[results=rd,stage=build]{Rdpack::insert_ref(key="#1",package="#2")}} \newcommand{\insertRef}{\Sexpr[results=rd,stage=build]{if(!exists(".Rdpack.currefs")) .Rdpack.currefs <- new.env(); Rdpack::insert_ref(key="#1",package="#2", cached_env=.Rdpack.currefs)}} % insert reference #1 - key, #2 - package \newcommand{\insertCiteOnly}{\Sexpr[results=rd,stage=build]{if(!exists(".Rdpack.currefs")) .Rdpack.currefs <- new.env();Rdpack::insert_citeOnly(key="#1",package="#2", cached_env=.Rdpack.currefs,cite_only=TRUE)}} \newcommand{\insertCite}{\Sexpr[results=rd,stage=build]{if(!exists(".Rdpack.currefs")) .Rdpack.currefs <- new.env();Rdpack::insert_citeOnly(key="#1",package="#2", cached_env=.Rdpack.currefs)}} \newcommand{\insertNoCite}{\Sexpr[results=hide,stage=build]{if(!exists(".Rdpack.currefs")) .Rdpack.currefs <- new.env();Rdpack::insert_citeOnly(key="#1",package="#2", cached_env=.Rdpack.currefs,dont_cite=TRUE)}} \newcommand{\insertAllCited}{\Sexpr[results=rd,stage=build]{if(!exists(".Rdpack.currefs")) .Rdpack.currefs <- new.env();Rdpack::insert_all_ref(.Rdpack.currefs)}} % insert reference #1 - key, #2 - package %\newcommand{\runExamples}{\Sexpr[results=rd,stage=build]{deparse({#1})}} \newcommand{\runExamples}{\Sexpr[results=rd,stage=build]{Rdpack:::run_examples(quote({#1}))}} %\newcommand{\printExample}{\Sexpr[results=rd,stage=build]{Rdpack:::run_examples(quote({#1}), Rdsection = "\\\\\\\\preformatted")}} \newcommand{\printExample}{\Sexpr[results=rd,stage=build]{.Rdpack.e <- environment();Rdpack:::run_examples(quote({#1}), local = .Rdpack.e, Rdsection = "preformatted")}} %\newcommand{\printExample}{\Sexpr[results=rd,stage=build]{Rdpack:::run_examples(quote({#1}), local = parent.frame(), Rdsection = "preformatted")}} % insert reference #1 - filename, #2 - package \newcommand{\insertFig}{\Sexpr[results=rd,stage=build]{Rdpack:::insert_fig("#1","#2", { #3 })}} \newcommand{\makeFig}{\Sexpr[results=hide,stage=build]{Rdpack:::insert_fig("#1","#2", { #3 }, insert=FALSE)}} Rdpack/man/Rdo_which.Rd0000644000175000017500000000425613733735617014606 0ustar nileshnilesh\name{Rdo_which} \alias{Rdo_which} \alias{Rdo_which_tag_eq} \alias{Rdo_which_tag_in} %- Also NEED an '\alias' for EACH other topic documented here. \title{Find elements of Rd objects for which a condition is true} \description{Find elements of Rd objects for which a condition is true.} \usage{ Rdo_which(rdo, fun) Rdo_which_tag_eq(rdo, tag) Rdo_which_tag_in(rdo, tags) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object.} \item{fun}{a function to evaluate with each element of \code{rdo}.} \item{tag}{a character string.} \item{tags}{a character vector.} } \details{ These functions return the indices of the (top level) elements of \code{rdo} which satisfy a condition. \code{Rdo_which} finds elements of \code{rdo} for which the function \code{fun} gives TRUE. \code{Rdo_which_tag_eq} finds elements with a specific \code{Rd_tag}. \code{Rdo_which_tag_in} finds elements whose \code{Rd_tag}'s are among the ones specified by \code{tags}. %% ~~ If necessary, more details than the description above ~~ } \value{ a vector of positive integers } % \references{ % %% ~put references to the literature/web site here ~ % } \author{Georgi N. Boshnakov} % \note{ % %% ~~further notes~~ % } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{Rdo_locate}} which searches recursively the Rd object. } \examples{ ## get the help page for topoc seq() rdo_seq <- tools::Rd_db("base")[["seq.Rd"]] ## find location of aliases in the topic ( ind <- Rdo_which_tag_eq(rdo_seq, "\\alias") ) ## extract the first alias rdo_seq[[ ind[1] ]] \dontrun{ ## extract all aliases rdo_seq[ind] } ## db_bibtex <- tools::Rd_db("bibtex") ## names(db_bibtex) ## ## Rdo object for read.bib() ## rdo_read.bib <- db_bibtex[["read.bib.Rd"]] ## Rdo_tags(rdo_read.bib) ## ## ## which elements of read.bib are aliases? ## Rdo_which_tag_eq(rdo_read.bib, "\\alias") ## rdo_read.bib[[3]] ## ## ## which elements of read.bib contain R code? ## Rdo_which(rdo_read.bib, function(x) any(Rdo_tags(x) == "RCODE") ) ## rdo_read.bib[[5]] ## ## which contain prose? ## Rdo_which(rdo_read.bib, function(x) any(Rdo_tags(x) == "TEXT") ) } \keyword{Rd} Rdpack/man/Rdo_locate.Rd0000644000175000017500000000660613501141722014731 0ustar nileshnilesh\name{Rdo_locate} \alias{Rdo_locate} \title{Find positions of elements in an Rd object} \description{ Find positions of elements for which a function returns TRUE. Optionally, apply another function to the selected elements and return the results along with the positions. } \usage{ Rdo_locate(object, f = function(x) TRUE, pos_only = TRUE, lists = FALSE, fpos = NULL, nested = TRUE) } \arguments{ \item{object}{an Rd object} \item{f}{a function returning TRUE if an element is desired and FALSE otherwise.} \item{pos_only}{if TRUE, return only the positions; if this argument is a function, return also the result of applying the function to the selected element, see Details.} \item{lists}{if FALSE, examine only leaves, if TRUE, examine also lists, see Details.} \item{fpos}{a function with two arguments, \code{object} and position, it is called and the value is returned along with the position, see Details.} \item{nested}{a logical value, it has effect only when \code{lists} is TRUE, see `Details'. } } \details{ With the default setting of \code{lists = FALSE}, the function \code{f} is applied to each leave (a character string) of the Rd object. If \code{lists = TRUE} the function \code{f} is applied also to each branch (a list). In this case, argument \code{nested} controls what happens when \code{f} returns TRUE. If \code{nested} is TRUE, each element of the list is also inspected recursively, otherwise this is not done and, effectively, the list is considered a leaf. If \code{f} does not return TRUE, the value of \code{nested} has no effect and the elements of the list are inspected. The position of each object for which \code{f} returns TRUE is recorded as a numeric vector. \code{fpos} and \code{pos_only} provide two ways to do something with the selected elements. Argument \code{fpos} is more powerful than \code{pos_only} but the latter should be sufficient and simpler to use in most cases. If \code{fpos} is a function, it is applied to each selected element with two arguments, \code{object} and the position, and the result returned along with the position. In this case argument \code{pos_only} is ignored. If \code{fpos} is NULL the action depends on \code{pos_only}. If \code{pos_only = TRUE}, \code{Rdo_locate} returns a list of such vectors (not a matrix since the positions of the leaves are, in general, at different depths). If \code{pos_only} is a function, it is applied to each selected element and the result returned along with the position. } \value{ a list with one entry for each selected element. Each entry is a numeric vector or a list with two elements: \item{pos}{the position, a vector of positive integers,} \item{value}{the result of applying the function to the element at \code{pos}.} } \author{Georgi N. Boshnakov} \note{ The following needs additional thought. In some circumstances an empty list, tagged with \code{Rd_tag} may turn up, e.g. \code{list()} with \verb{Rd_tag="\\dots"} in an \verb{\\arguments} section. On the one hand this is a list. On the other hand it may be considered a leaf. It is not clear if any attempt to recurse into such a list should be made at all. } \seealso{ \code{\link{Rdo_sections}} and \code{\link{Rdo_locate_core_section}} which locate top level sections } \examples{ # todo: put examples here! } \keyword{Rd} Rdpack/man/Rdpack_bibstyles.Rd0000644000175000017500000000403213501141722016131 0ustar nileshnilesh\name{Rdpack_bibstyles} \alias{Rdpack_bibstyles} %- Also NEED an '\alias' for EACH other topic documented here. \title{Set up a custom style for references in help pages} \description{Set up a custom style for references in help pages.} \usage{ Rdpack_bibstyles(package, authors) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{package}{the name of a package, a character string.} \item{authors}{if equal to "LongNames", use full names of authors in reference lists, see Details.} } \details{ This is the initial implementation of support for styles for lists of bibliography references. Currently setting "authors" to "LongNames" will cause the references to appear with full names, eg John Smith rather than in the default Smith J style. Package authors can request this feature by adding the following line to their \code{.onLoad} function (if their package has one): \preformatted{ Rdpack::Rdpack_bibstyles(package = pkg, authors = "LongNames") } of just copy the following definition in a package that does not have \code{.onLoad} : \preformatted{ .onLoad <- function(lib, pkg){ Rdpack::Rdpack_bibstyles(package = pkg, authors = "LongNames") invisible(NULL) } } After building and installing the package the references should be using long names. } \value{ in .onLoad(), the function is used purely to set up a bibstyle as discussed in Details. Internally, \pkg{Rdpack} uses it to extract styles set up by packages: - if called with argument \code{package} only, the style requested by that package; - if called with no arguments, a list of all styles. } %\references{ %} \author{Georgi N. Boshnakov} %\note{ %%% ~~further notes~~ %} %% ~Make other sections like Warning with \section{Warning }{....} ~ %\seealso{ %%% ~~objects to See Also as \code{\link{help}}, ~~~ %} %\examples{ %} % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{documentation} \keyword{bibtex} % use one of RShowDoc("KEYWORDS") Rdpack/man/promptUsage.Rd0000644000175000017500000001505714041230133015157 0ustar nileshnilesh\name{promptUsage} \alias{promptUsage} \alias{get_usage} \title{ Generate usage text for functions and methods \Sexpr[stage=build,results=hide]{require(Rdpack)} } \description{ Generates usage text for a function, S3 method or S4 method. The text is suitably formatted for inclusion in the usage section of Rd documentation. } \usage{ get_usage(object, name = NULL, force.function = FALSE, \dots, S3class = "", S4sig = "", infix = FALSE, fu = TRUE, out.format = "text") promptUsage(\dots, usage) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{object}{a function object or a character name of one, can be anonymous function.} \item{name}{the name of a function, a string.} \item{force.function}{enforce looking for a function.} \item{S3class}{the S3 class of the function, a character vector.} \item{out.format}{if "\verb{text}", return the result as a character vector.} \item{S4sig}{(the signature of an S4 method, as used in Rd macro \verb{\S4method}).} \item{infix}{if TRUE the function is an infix operator.} \item{fu}{if TRUE the object is a function, otherwise it is something else (e.g. a variable or a constant like \code{pi} and \code{Inf}). } \item{usage}{an usage object, see Details.} \item{\dots}{ for \code{promptUsage}, arguments to be passed on to \code{get_usage}; for \code{get_usage}, currently not used. } } \details{ \code{get_usage()} takes a function object, or the name of one, and creates text suitable for inclusion in the usage section of Rd documentation. The usage is generated from the function object. When in interactive \R session, use \code{cat()} to print the result for copying and pasting into Rd documentation or saving to a file (otherwise, if the usage text contains backslashes, they may appear duplicated). Long text is wrapped on two or more lines. For example, \printExample{cat( get_usage(lm) )} Argument \code{"name"} can be used to specify a print name for the function. This is most often needed for S3 methods. Compare \printExample{cat( get_usage(summary.lm) )} and \printExample{cat( get_usage(summary.lm, name = "summary") )} The call is just \code{summary()} in the latter. This fairly reflects the fact that S3 methods are normally called via the generic, but adding some explanatory text around the command is usually a good idea. For programmatically generated usage sections in help pages, argument \code{S3class} can be used to get the standard Rd markup for S3 methods. \printExample{cat( get_usage(summary.lm, "summary", S3class = "lm") )} (Note that \verb{\method} can only be used in Usage sections.) When \code{object} is an anonymous function, argument \code{name} is compulsory. For example, % this code prints ugly: \printExample{cat( get_usage(function(x = 3, y="a"){}, "f") )} % so do it manually in two steps: \code{cat( get_usage(function(x = 3, y = "a"){}, "f") )} % TODO: this is commented out from the pkgdown site, since pkgdown() doesn't handle % results=verbatim yet. %\Sexpr[stage=build,results=verbatim]{cat("##: ", get_usage(function(x = 3, y = "a"){}, "f"), "\n" )} \code{get_usage()} can also be used to insert dynamically signatures of functions located in other objects, such as environments and lists, see the examples. If a function is used as an infix operator, set \code{infix = TRUE}. \printExample{get_usage("+", infix = TRUE); get_usage("\\\%in\\\%", infix = TRUE)} The name of the operator may be in a variable: \printExample{op <- "+"; get_usage(op, infix = TRUE)} Backticks are ok, as well, \printExample{get_usage(`+`, infix = TRUE)} But if a backticked operator is in a variable, surprise springs: \printExample{op <- `+`; get_usage(op, infix = TRUE)} In this case, don't use backticks or, if you must, evaluate the argument: \printExample{op <- `+`; get_usage(eval(op), name = "+", infix = TRUE)} % \Sexpr[stage=build,results=hide]{wrap_percent <- function(x) paste0("\%", x, "\%")} % \printExample{op <- wrap_percent("in"); get_usage(op, infix = TRUE)} % \printExample{op <- as.name(wrap_percent("in")); get_usage(eval(op), name = "in", infix = TRUE)} % \printExample{op <- as.name(wrap_percent("in")); get_usage(eval(op), name = wrap_percent("in"), infix = TRUE)} % \printExample{op <- as.name(wrap_percent("in")); get_usage(`\\\%in\\\%`, name = wrap_percent("in"), infix = TRUE)} % \strong{Sexpr:} % \Sexpr[stage=build,results=verbatim]{op <- as.name(wrap_percent("in")); get_usage(eval(op), name = wrap_percent("in"), infix = TRUE)} % \Sexpr[stage=build,results=verbatim]{op} % \Sexpr[stage=build,results=verbatim]{cat(wrap_percent("in"), "\n")} % \Sexpr[stage=build,results=verbatim]{e <- environment(); ls(e)} \code{promptUsage()} is mostly for internal use. It is like \code{get_usage()} with an additional argument, \code{usage}, used to pass a specially parsed argument list of class \verb{"f_usage"}, produced by other functions in \pkg{Rdpack}. In particular it could have been generated by a previous call to \code{get_usage()}. } \value{ a character string or an object of S3 class "\verb{f_usage}", see \code{\link{pairlist2f_usage1}} for its format. } \author{Georgi N. Boshnakov} \note{ For an S3 or S4 generic, use the name of the function, not the object, see the examples. These functions are for usage descriptions as they appear in the "usage" section of Rd files. Descriptions of S4 methods for "Methods" sections are dealt with by other functions. } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{parse_pairlist}} } \examples{ u <- get_usage(lm) # a long usage text cat(u) # if there are additional arguments in S3 methods, # use names of the functions, not the objects, e.g. get_usage("droplevels", S3class = "data.frame") get_usage(name = "droplevels", S3class = "data.frame") # (both give "\method{droplevels}{data.frame}(x, except = NULL, \dots)") # but this gives the args of the generic: "\method{droplevels}{data.frame}(x, \dots)" get_usage(droplevels, S3class = "data.frame") ## a list containing some functions summaries <- list(xbar = function(x) mean(x), rho = function(x, y) cor(x,y)) get_usage(summaries$xbar, name = "xbar") get_usage(summaries$rho, name = "rho") ## functions in an environment esummaries <- list2env(summaries) get_usage(esummaries$xbar, name = "xbar") get_usage(esummaries$rho, name = "rho") } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{documentation} \keyword{Rd} Rdpack/man/insert_citeOnly.Rd0000644000175000017500000000345414200041754016027 0ustar nileshnilesh\name{insert_citeOnly} \alias{insert_citeOnly} \title{Generate citations from bibtex files} \description{Generate citations from bibtex files.} \usage{ insert_citeOnly(keys, package = NULL, before = NULL, after = NULL, bibpunct = NULL, ..., cached_env = NULL, cite_only = FALSE, dont_cite = FALSE) } \arguments{ \item{keys}{bibtex key(s), a character vector.} \item{package}{name of an R package.} \item{before}{see \code{\link{citeNatbib}}.} \item{after}{see \code{\link{citeNatbib}}.} \item{bibpunct}{see \code{\link{citeNatbib}}.} \item{\dots}{further arguments.} \item{cached_env}{for internal use.} \item{cite_only}{for internal use.} \item{dont_cite}{for internal use.} } \details{ This is the function behind \verb{\\insertCite} and related macros. } \value{ a character vector containing the references with Rd markup } %\references{ %%% ~put references to the literature/web site here ~ %} \author{Georgi N. Boshnakov} %\note{ %%% ~~further notes~~ %} % %%% ~Make other sections like Warning with \section{Warning }{....} ~ % \seealso{ \code{\link{insert_ref}} for description of all available Rd macros } \examples{ insert_citeOnly("@see also @Rpackage:rbibutils and @parseRd", package = "Rdpack") ## (see also Boshnakov and Putman 2020 and Murdoch 2010) insert_citeOnly("@see also @Rpackage:rbibutils and @parseRd;nobrackets", package = "Rdpack") ## see also Boshnakov and Putman 2020 and Murdoch 2010 } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory (show via RShowDoc("KEYWORDS")): \keyword{documentation} % \keyword{ ~kwd2 } % Use only one keyword per line. % For non-standard keywords, use \concept instead of \keyword: % \concept{ ~cpt1 } % \concept{ ~cpt2 } % Use only one concept per line. Rdpack/man/parse_pairlist.Rd0000644000175000017500000000710514041230077015674 0ustar nileshnilesh\name{parse_pairlist} \alias{parse_pairlist} %\alias{pairlist2f_usage} \alias{pairlist2f_usage1} \title{ Parse formal arguments of functions \Sexpr[stage=build,results=hide]{require(Rdpack)} } \description{Parse formal arguments of functions and convert them to f_usage objects.} \usage{ parse_pairlist(x) pairlist2f_usage1(x, name, S3class = "", S4sig = "", infix = FALSE, fu = TRUE) } \arguments{ \item{x}{a pairlist representing the arguments of a function.} \item{name}{function name.} \item{S3class}{S3 class, see `Details'} \item{S4sig}{S4 signature, see Details.} \item{infix}{if \code{TRUE} the function usage is in infix form, see Details.} \item{fu}{if TRUE the object is a function, otherwise it is something else (e.g. a variable or a constant like \code{pi} and \code{Inf}). } } \details{ These functions are mostly internal. % \code{x} is a single pairlist object for \code{parse_pairlist} and % \code{pairlist2f_usage1}. % For \code{pairlist2f_usage} it may be a list of pairlist objects. % (\code{pairlist2f_usage} has been removed) \code{parse_pairlist} parses the pairlist object, \code{x}, into a list with two components. The first component contains the names of the arguments. The second component is a named list containing the default values, converted to strings. Only arguments with default values have entries in the second component (so, it may be of length zero). If \code{x} is empty or \code{NULL}, both components have length zero. An example: \printExample{parse_pairlist(formals(system.file))} \code{pairlist2f_usage1()} creates an object of S3 class \code{"f_usage"}. The object contains the result of parsing \code{x} with \code{parse_pairlist(x)} and a number of additional components which are copies of the remaining arguments to the function (without any processing). The components are listed in section Values. \code{S3class} is set to an S3 class for for S3 methods, \code{S4sig} is the signature of an S4 method (as used in Rd macro \verb{\S4method}). \code{infix} is \code{TRUE} for the rare occations when the function is primarily used in infix form. Class \code{"f_usage"} has a method for \code{as.character()} which generates a text suitable for inclusion in Rd documentation. \printExample{pairlist2f_usage1(formals(summary.lm), "summary", S3class = "lm")} } \value{ For \code{parse_pairlist}, a list with the following components: \item{argnames}{the names of all arguments, a character vector} \item{defaults}{ a named character vector containing the default values, converted to character strings. Only arguments with defaults have entries in this vector. } For \code{pairlist2f_usage1}, an object with S3 class \code{"f_usage"}. This is a list as for \code{parse_pairlist} and the following additional components: \item{name}{function name, a character string.} \item{S3class}{ S3 class, a character string; \code{""} if not an S3 method. } \item{S4sig}{S4 signature; \code{""} if not an S4 method.} \item{infix}{a logical value, \code{TRUE} for infix operators.} \item{fu}{ indicates the type of the object, usually \code{TRUE}, see Details. } % For \code{pairlist2f_usage}, a list of \code{"f_usage"} objects. } \author{Georgi N. Boshnakov} \seealso{ \code{\link{promptUsage}} accepts \code{f_usage} objects, \code{\link{get_usage}} } \examples{ parse_pairlist(formals(lm)) parse_pairlist(formals(system.file)) s_lm <- pairlist2f_usage1(formals(summary.lm), "summary", S3class = "lm") s_lm as.character(s_lm) } \keyword{RdoBuild} Rdpack/man/parse_Rdname.Rd0000644000175000017500000000264413501141722015254 0ustar nileshnilesh\name{parse_Rdname} \alias{parse_Rdname} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Parse the name section of an Rd object } \description{ Parse the name section of an Rd object. } \usage{ parse_Rdname(rdo) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object} } \details{ The content of section "\verb{\name}" is extracted. If it contains a hyphen, `-', the part before the hyphen is taken to be the topic (usually a function name), while the part after the hyphen is the type. If the name does not contain hyphens, the type is set to the empty string. } \value{ a list with two components: \item{fname}{name of the topic, usually a function} \item{type}{type of the topic, such as \verb{"method"}} } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ u1 <- list_Rd(name = "Dummyname", alias = "Dummyallias1", title = "Dummy title", description = "Dummy description", Rd_class=TRUE ) parse_Rdname(u1) u2 <- list_Rd(name = "dummyclass-class", alias = "Dummyclass", title = "Class dummyclass", description = "Objects and methods for something.", Rd_class=TRUE ) parse_Rdname(u2) } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoProgramming} Rdpack/man/Rdo_remove_srcref.Rd0000644000175000017500000000162413501141722016316 0ustar nileshnilesh\name{Rdo_remove_srcref} \alias{Rdo_remove_srcref} %- Also NEED an '\alias' for EACH other topic documented here. \title{Remove srcref attributes from Rd objects} \description{Removes srcref attributes from Rd objects.} \usage{ Rdo_remove_srcref(rdo) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object} } \details{ \code{srcref} attrbutes (set by \code{parse_Rd}) may be getting in the way during manipulation of Rd objects, such as comparisons, addition and replacement of elements. This function traverses the argument and removes the \code{srcref} attribute from all of its elements. } \value{ an Rd object with no srcref attributes. } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoProgramming} Rdpack/man/viewRd.Rd0000644000175000017500000000256514177463245014137 0ustar nileshnilesh\name{viewRd} \alias{viewRd} \title{View Rd files in a source package} \description{View Rd files in a source package.} \usage{ viewRd(infile, type = getOption("help_type"), stages = NULL) } \arguments{ \item{infile}{name of an Rd file, a character string.} \item{type}{one of \code{"text"} or \code{"html"}} \item{stages}{ a character vector specifying which stages of the R installation process to immitate. The default, \code{c("build", "install", "render")}, should be fine in most cases. } } \details{ This function can be used to view Rd files from the source directory of a package. The page is presented in text format or in html browser, according to the setting of argument \code{type}. The default is \code{getOption("help_type")}. } \value{ the function is used for the side effect of showing the help page in a text help window or a web browser. } %\references{ %%% ~put references to the literature/web site here ~ %} \author{Georgi N. Boshnakov} \note{ Developers with \code{"devtools"} can use \code{viewRd()} instead of \code{help()} for documentation objects that contain Rd macros, such as \code{insertRef}, see vignette: \code{vignette("Inserting_bibtex_references", package = "Rdpack")}. } %\seealso{ %%% ~~objects to See Also as \code{\link{help}}, ~~~ %} %\examples{ %} \keyword{documentation} % use one of RShowDoc("KEYWORDS") Rdpack/man/Rdo_tag.Rd0000644000175000017500000000266413501141722014235 0ustar nileshnilesh\name{Rdo_tag} \alias{Rdo_comment} \alias{Rdo_verb} \alias{Rdo_Rcode} \alias{Rdo_text} \alias{Rdo_tag} \alias{Rdo_newline} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Set the Rd_tag of an object } \description{ Set the Rd_tag of an object. } \usage{ Rdo_comment(x = "\%\%") Rdo_tag(x, name) Rdo_verb(x) Rdo_Rcode(x) Rdo_text(x) Rdo_newline() } %- maybe also 'usage' for other objects documented here. \arguments{ \item{x}{an object, appropriate for the requested Rd_tag.} \item{name}{the tag name, a string.} } \details{ These functions simply set attribute "\verb{Rd_tag}" of \code{x}, effectively assuming that the caller has prepared it as needed. \code{Rdo_tag} sets the "\verb{Rd_tag}" attribute of \code{x} to \code{name}. The other functions are shorthands with a fixed name and no second argument. \code{Rdo_comment} tags an Rd element as comment. \code{Rdo_newline} gives an Rd element representing an empty line. } \value{ \code{x} with its "\verb{Rd_tag}" set to \code{name} (\code{Rdo_tag}), "TEXT" (\code{Rdo_text}), "VERB" (\code{Rdo_verb}) or "RCODE" (\code{Rdo_Rcode}). } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{RdoProgramming} %\keyword{RdoElements} \keyword{RdoBuild} Rdpack/man/format_funusage.Rd0000644000175000017500000000517213501141722016040 0ustar nileshnilesh\name{format_funusage} \alias{format_funusage} %- Also NEED an '\alias' for EACH other topic documented here. \title{Format the usage text of functions} \description{Formats the usage text of a function so that each line contains no more than a given number of characters.} \usage{ format_funusage(x, name = "", width = 72, realname) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{x}{a character vector containing one element for each argument of the function, see `Details'.} \item{name}{the name of the function whose usage is described, a string.} \item{width}{maximal width of each line of output.} \item{realname}{the printed form of \code{name}, see `Details', a string.} } \details{ \code{format_funusage} formats the usage text of a function for inclusion in Rd documentation files. If necessary, it splits the text into more lines in order to fit it within the requested width. Each element of argument \code{x} contains the text for one argument of function \code{name} in the form \code{arg} or \code{arg = default}. \code{format_funusage} does not look into the content of \code{x}, it does the necessary pasting to form the complete usage text, inserting new lines and indentation to stay within the specified width. Elements of \code{x} are never split. If an argument (i.e., element of \code{x}) would cause the width to be exceeded, the entire argument is moved to the following line. The text on the second and subsequent lines of each usage item starts in the column just after the opening parenthesis which follows the name of the function on the first line. In descriptions of S3 methods and S4 methods, argument \code{name} may be a TeX macro like \verb{\method{print}{ts}}. In that case the number of characters in \code{name} has little bearing on the actual number printed. In this case argument \code{realname} is used for counting both the number of characters on the first line of the usage message and the indentation for the subsequent lines. } \value{ The formatted text as a length one character vector. } \author{Georgi N. Boshnakov} \note{ Only the width of \code{realname} is used (for counting). The formatted text contains \code{name}. The width of strings is determined by calling \code{nchar} with argument \code{type} set to "width". } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{deparse_usage1}} } \examples{ # this function is essentially internal, # see deparse_usage1 and as.character.f_usage which use it. } %\keyword{RdoProgramming} \keyword{RdoUsage} %\keyword{RdFunction} Rdpack/man/rebib.Rd0000644000175000017500000001125413501141722013734 0ustar nileshnilesh\name{rebib} \alias{rebib} \alias{inspect_Rdbib} \title{Work with bibtex references in Rd documentation} \description{Work with bibtex references in Rd documentation.} \usage{ rebib(infile, outfile, \dots) inspect_Rdbib(rdo, force = FALSE, \dots) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{infile}{name of the Rd file to update, a character string.} \item{outfile}{a filename for the updated Rd object.} \item{...}{further arguments to be passed to \code{\link{get_bibentries}}, see `Details'.} \item{rdo}{an Rd object.} \item{force}{if TRUE, re-insert previously imported references. Otherwise do not change such references.} } \details{ \code{inspect_Rdbib} takes an Rd object and processes the references as specified below. The user level function is \code{rebib}. It parses the Rd file \code{infile}, calls \code{inspect_Rdbib} to process the references, and writes the modified Rd object to file \code{outfile}. If \code{outfile} is missing it is set to the basename of \code{infile}. If \code{outfile} is the empty string, \code{""}, then \code{outfile} is set to \code{infile}. The default Bibtex file is "REFERENCES.bib" in the current working directory. Arguments "\dots" can be used to change the name of the bib file and its location. Argument \code{bibfile} can be used to overwrite the default name of the bib file. Argument \code{package} can be used to specify that the bib file should be taken from the root of the installation directory of package \code{package}, see \code{\link{get_bibentries}} for details. The following scheme can be used for incorporation of bibliographic references from BibTeX files. Note however, that usually it is more convenient to use the approach based on Rd macros like \code{\\insertRef}, see \code{\link{insert_ref}} and the vignette(s). The Bibtex key for each reference is put in a comment line in the references section, as in \preformatted{ \references{ \% bibentry: key1 \% bibentry: key2 ... } } At least one space after the colon, ':', is required, spaces before "bibentry:" are ignored. Then run \code{rebib()} on the file, see the example section for a way to run \code{rebib()} on all files in one go. Each reference is inserted immediately after the comment line specifying it and a matching comment line marking its end is inserted. Before inserting a reference, a check for the matching ending line is made, and if such a line is found, the reference is not inserted. This means that to add new references it is sufficient to give their keys, as described above and run the function again. References that are already there will not be duplicated. The inserted reference may also be edited, if necessary. As long as the two comment lines enclosing it are not removed, the reference will not be overwritten by subsequent calls of the functions described here. Any text outside the markers delineating references inserted by this mechanism is left unchanged, including references inserted by other means. To include all references from the bib file, the following line can be used: \preformatted{ \% bibentry:all } Notice that there is no space after the colon in this case. In this case a marker is put after the last reference and the whole thing is considered one block. So, if the end marker is present and \code{force} is FALSE, none will will be changed. Otherwise, if \code{force} is TRUE, the whole block of references will be removed and all references currently in the bib file will be inserted. The main purpose of \verb{bibentry:all} is for use in a package overview file. The reference section in the file "package-package" generated by \code{\link{promptPackageSexpr}} uses this feature (but the user still needs to call \code{rebib} to insert the references). } \value{ for \code{inspect_Rdbib}, the modified Rd object. \code{rebib} is used mainly for the side effect of creating a file with the references updated. It returns the Rd object created by parsing and modifying the Rd file. } % \references{ % %% ~put references to the literature/web site here ~ % } \author{Georgi N. Boshnakov} % \note{ % %% ~~further notes~~ % } % % %% ~Make other sections like Warning with \section{Warning }{....} ~ % \seealso{ \code{\link{insert_ref}} and the vignette(s) for the recommended way to import BibTeX references and citations. } \examples{ \dontrun{ # update references in all Rd files in the package's 'man' directory # rdnames <- dir(path = "./man", pattern=".*[.]Rd$", full.names=TRUE) lapply(rdnames, function(x) rebib(x, package="Rdpack")) } } \keyword{bibtex} \keyword{Rd} Rdpack/man/parse_text.Rd0000644000175000017500000000327613677310045015046 0ustar nileshnilesh\name{parse_text} \alias{parse_text} %- Also NEED an '\alias' for EACH other topic documented here. \title{Parse expressions residing in character vectors} \description{Parse expressions residing in character vectors.} \usage{ parse_text(text, ..., keep = TRUE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{text}{the text to parse, normally a character vector but can be anything that \code{parse} accepts for this artgument.} \item{\dots}{additional arguments to be passed on to \code{parse}.} \item{keep}{required setting for option \verb{keep.source}, see details.} } \details{ This is like \code{parse(text=text,\dots)} with the additional feature that if the setting of option "keep.source" is not as requested by argument \code{keep}, it is set to \code{keep} before calling \code{parse} and restored afterwards. This function is no longer exported by \pkg{Rdpack} since it is here for historical reasons and to avoid unnecessary dependence on \pkg{gbutils}. Use the equivalent \code{gbutils::parse_text} instead. } \value{ an expression representing the parsed text, see \code{link{parse}} for details } \author{Georgi N. Boshnakov} \note{ The usual setting of option "keep.source" in interactive sessions is TRUE. However, in `R CMD check' it is FALSE. As a consequence, examples from the documentation may run fine when copied and pasted in an R session but (rightly) fail `R CMD check', when they depend on option "keep.source" being \code{TRUE}. } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{parse}}, \code{parse_text} in package gbutils } \keyword{programming} \keyword{internal} Rdpack/man/Rdo_collect_metadata.Rd0000644000175000017500000000404313501141722016740 0ustar nileshnilesh\name{Rdo_collect_aliases} \alias{Rdo_collect_aliases} \alias{Rdo_collect_metadata} \title{Collect aliases or other metadata from an Rd object} \description{Collect aliases or other metadata from an Rd object.} \usage{ Rdo_collect_aliases(rdo) Rdo_collect_metadata(rdo, sec) } \arguments{ \item{rdo}{an Rd object} \item{sec}{the kind of metadata to collect, a character string, such as "alias" and "keyword".} } \details{ \code{Rdo_collect_aliases} finds all aliases in \code{rdo} and returns them as a named character vector. The name of an alias is usually the empty string, \code{""}, but it may also be "windows" or "unix" if the alias is wrapped in a \verb{#ifdef} directive with the corresponding first argument. \code{Rdo_collect_metadata} is a generalisation of the above. It collects the metadata from section(s) \code{sec}, where \code{sec} is the name of a section without the leading backslash. \code{sec} is assumed to be a section containing a single word, such as "keyword", "alias", "name". Currently \code{Rdo_collect_metadata} is not exported. } \value{ a named character vector, as described in Details. } \author{Georgi N. Boshnakov} \seealso{ \code{tools:::.Rd_get_metadata} } \examples{ ## this example originally (circa 2012) was: ## infile <- file.path(R.home(), "src/library/base/man/timezones.Rd") ## but the OS conditional alias in that file has been removed. ## So, create an artificial example: infile <- system.file("examples", "tz.Rd", package = "Rdpack") ## file.show(infile) rd <- tools::parse_Rd(infile) ## The functions described here handle "ifdef" and similar directives. ## This detects OS specific aliases (windows = "onlywin" and unix = "onlyunix"): Rdo_collect_aliases(rd) Rdpack:::Rdo_collect_metadata(rd, "alias") # same ## In contrast, the following do not find "onlywin" and "onlyunix": sapply(rd[which(tools:::RdTags(rd)=="\\alias")], as.character) tools:::.Rd_get_metadata(rd, "alias") Rdpack:::Rdo_collect_metadata(rd, "name") Rdpack:::Rdo_collect_metadata(rd, "keyword") } \keyword{Rd} Rdpack/man/reprompt.Rd0000644000175000017500000003617313646061720014541 0ustar nileshnilesh\name{reprompt} \alias{reprompt} \title{Update the documentation of a topic} \description{Examine the documentation of functions, methods or classes and update it with additional arguments, aliases, methods or slots, as appropriate. This is an extention of the promptXXX() family of functions. } \usage{ reprompt(object, infile = NULL, Rdtext = NULL, final = TRUE, type = NULL, package = NULL, methods = NULL, verbose = TRUE, filename = NULL, sec_copy = TRUE, edit = FALSE, \dots) } \arguments{ \item{object}{the object whose documentation is to be updated, such as a string, a function, a help topic, a parsed Rd object, see `Details'.} \item{infile}{a file name containing Rd documentation, see `Details'.} \item{Rdtext}{a character string with Rd formatted text, see `Details'.} \item{final}{logical, if \code{TRUE} modifies the output of \code{prompt} so that the package can be built.} \item{type}{type of topic, such as \code{"methods"} or \code{"class"}, see `Details'.} \item{package}{package name; document only objects defined in this package, especially useful for methods, see `Details'.} \item{methods}{ used for documentation of S4 methods only, rarely needed even for them. This argument is passed on to \code{\link[methods]{promptMethods}}, see its documentation for details. } \item{verbose}{if \code{TRUE} print messages on the screen.} \item{filename}{name of the file for the generated Rd content; if \code{NULL}, a suitable file name is generated, if \code{TRUE} it will be set to \code{infile}, if \code{FALSE} the Rd text is returned, see `Details'.} \item{\dots}{currently not used.} \item{sec_copy}{if \code{TRUE} copy Rd contents of unchanged sections in the result, see Details.} \item{edit}{if \code{TRUE} call \code{file.edit} just before returning. This argument is ignored if \code{filename} is \code{FALSE}.} } \details{ The typical use of \code{reprompt} is with one argument, as in \preformatted{ reprompt(infile = "./Rdpack/man/reprompt.Rd") reprompt(reprompt) reprompt("reprompt") } \code{reprompt} updates the requested documentation and writes the new Rd file in the current working directory. When argument \code{infile} is used, the descriptions of all objects described in the input file are updated. When an object or its name is given, \code{reprompt} looks first for installed documentation and processes it in the same way as in the case of \code{infile}. If there is no documentation for the object, \code{reprompt} creates a skeleton Rd file similar to the one produced by the base R functions from the \code{prompt} family (if \code{final = TRUE}, the default, it modifies the output of \code{prompt()}, so that the package can be built). To document a function, say \code{myfun}, in an existing Rd file, just add \code{myfun()} to the usage section in the file and call \code{reprompt()} on that file. Put quotes around the function name if it is non-syntactic. For replacement functions (functions with names ending in \code{<-}) \code{reprompt()} will insert the proper usage statement. For example, if the signature of \code{xxx<-} is \code{(x, ..., value)} then both, \code{"xxx<-"()} and \code{xxx() <- value} will be replaced by \code{xxx(x, ...) <- value}. For S4 methods and classes the argument "package" is often needed to restrict the output to methods defined in the package of interest. \preformatted{ reprompt("myfun-methods") reprompt("[<--methods", package = "mypackage") reprompt("[<-", type = "methods", package = "mypackage") # same reprompt("myclass", type = "class", package = "mypackage") reprompt("myclass-class", package = "mypackage") # same } Without the "package" argument the reprompt for \code{"[<-"} would give all methods defined by loaded packages at the time of the call. Currently \code{reprompt} functionality is not implemented for topic "package" but if \code{object} has the form "name-package" (or the equivalent with argument \code{topic}) and there is no documentation for \code{package?name}, \code{reprompt} calls \code{\link{promptPackageSexpr}} to create the required shell. Note that the shell produced by \code{promptPackageSexpr} does not need `reprompting' since the automatically generated information is included by \verb{\Sexpr}'s, not literal strings. Below are the details. Typically, only one of \code{object}, \code{infile}, and \code{Rdtext} is supplied. Warning messages are issued if this is not the case. The object must have been made available by the time when \code{reprompt()} is issued. If the object is in a package this is typically achieved by a \code{library()} command. \code{object} may be a function or a name, as accepted by the \code{?} operator. If it has the form "name-class" and "name-methods" a documentation shell for class "name" or the methods for generic function "name" will be examined/created. Alternatively, argument \code{type} may be set to "class" or "methods" to achieve the same effect. \code{infile} specifies a documentation file to be updated. If it contains the documentation for one or more functions, \code{reprompt} examines their usage statements and updates them if they have changed. It also adds arguments to the "arguments" section if not all arguments in the usage statements have entries there. If \code{infile} describes the methods of a function or a class, the checks made are as appropriate for them. For example, new methods and/or slots are added to the corresponding sections. It is all too easy in interactive use to forget to name the \code{infile} argument, compare\cr \code{reprompt("./man/reprompt.Rd")} vs. \code{reprompt(infile = "./man/reprompt.Rd")}).\cr A convenience feature is that if \code{infile} is missing and \code{object} is a character string ending in ".Rd" and containing a forward slash (i.e. it looks like Rd file in a directory), then it is taken to be \code{infile}. \code{Rdtext} is similar to \code{infile} but the Rd content is taken from a character vector. If Rd content is supplied by \code{infile} or \code{Rdtext}, \code{reprompt} uses it as a basis for comparison. Otherwise it tries to find installed documentation for the object or topic requested. If that fails, it resorts to one of the \code{promptXXX} functions to generate a documentation shell. If that also fails, the requested object or topic does not exist. If the above succeeds, the function examines the current definition of the requested object(s), methods, or class and amends the documentation with any additional items it finds. For Rd objects describing one or more functions, the usage expressions are checked and replaced, if they have changed. Arguments appearing in one or more usage expressions and missing from section "Arguments" are amended to it with content "Describe ..." and a message is printed. Arguments no longer in the usage statements are NOT removed but a message is issued to alert the user. Alias sections are inserted for any functions with "usage" but without "alias" section. If \code{filename} is a character string, it is used as is, so any path should be included in the string. Argument \code{filename} usuallly is omitted since the automatically generated file name is suitable in most cases. Exceptions are functions with non-standard names (such as replacement functions whose names end in \code{"<-"}) for which the generated file names may not be acceptable on some operating systems. If \code{filename} is missing or \code{NULL}, a suitable name is generated as follows. If \code{infile} is supplied, \code{filename} is set to a file with the same name in the current working directory (i.e. any path information in \code{infile} is dropped). Otherwise, \code{filename} is obtained by appending the name tag of the Rd object with \code{".Rd"}. If \code{filename} is \code{TRUE}, it is set to \code{infile} or, if \code{infile} is missing or \code{NULL}, a suitable name is generated as above. This can be used to change \code{infile} in place. If \code{filename} is \code{FALSE}, the Rd text is returned as a character vector and not written to a file. If \code{edit} is \code{TRUE}, the reprompted file is opened in an editor, see also \code{\link{ereprompt}} (`e' for `edit') which is like \code{reprompt} but has as default \code{edit = TRUE} and some other related settings. \code{file.edit()} is used to call the editor. Which editor is opened depends on the OS and on the user configuration. RStudio users will probably prefer the 'Reprompt' add-in or the underlying function \code{\link{RStudio_reprompt}}. Emacs users would normally have set up \code{emacsclient} as their editor and this is automatically done by EMACS/ESS (even on Windows). If argument \code{sec_copy} is \code{TRUE} (the default), \code{reprompt} will, effectively, copy the contents of (some) unchanged sections, thus ensuring that they are exactly the same as in the original. This needs additional work, since parsing an Rd file and then exporting the created Rd object to an Rd file does not necessarilly produce an identical Rd file (some escape sequences may be changed in the process, for example). Even though the new version should be functionally equivalent to the original, such changes are usually not desirable. For example, if such changes creep into the Details section (which \code{reprompt} never changes) the user may be annoyed or worried. } \value{ if \code{filename} is a character string or \code{NULL}, the name of the file to which the updated shell was written. Otherwise, the Rd text is returned as a character vector. } \author{Georgi N. Boshnakov} \note{ The arguments of \code{reprompt} are similar to prompt, with some additions. As in \code{prompt}, \code{filename} specifies the output file. In \code{reprompt} a new argument, \code{infile}, specifies the input file containing the Rd source. When \code{reprompt} is used to update sources of Rd documentation for a package, it is best to supply the original Rd file in argument \code{infile}. Otherwise, if the original Rd file contains \verb{\Sexpr} commands, \code{reprompt} may not be able to recover the original Rd content from the installed documentation. Also, the fields (e.g. the keywords) in the installed documentation may not be were you expect them to be. (This may be addressed in a future revision.) While \code{reprompt} adds new items to the documentation, it never removes existing content. It only issues a suggestion to remove an item, if it does not seem necessary any more (e.g. a removed argument from a function definition). \code{reprompt} handles usage statements for S3 and S4 methods introduced with any of the macros \verb{\method}, \verb{\S3method} and \verb{\S4method}, as in \verb{\method{fun}{class}(args...)}. \code{reprompt} understands also subsetting ans subassignment operators. For example, suppose that the \code{\\arguments} section of file "bracket.Rd" contains these directives (or any other wrong signatures): \preformatted{ \method{[}{ts}() \method{[[}{Date}() } Then \code{reprompt("./bracket.Rd")} will change them to \preformatted{ \method{[}{ts}(x, i, j, drop = TRUE) \method{[[}{Date}(x, \dots, drop = TRUE) } This works for the assignment operators and functions, as well. For example, any of these \preformatted{ \method{`[<-`}{POSIXlt}() \method{[}{POSIXlt}(x, j) <- value } will be converted by \code{reprompt} to the standard form \preformatted{ \method{[}{POSIXlt}(x, i, j) <- value } Note that the quotes in \code{`[<-`} above. Usage statements for functions are split over two or more lines if necessary. The user may edit them afterwards if the automatic splitting is not appropriate, see below. The usage section of Rd objects describing functions is left intact if the usage has not changed. To force \code{reprompt} to recreate the usage section (e.g. to reformat long lines), invalidate the usage of one of the described functions by removing an argument from its usage expression. Currently the usage section is recreated completely if the usage of any of the described functions has changed. Manual formatting may be lost in such cases. } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{ereprompt}} which by default calls the editor on the original file } \examples{ ## note: usage of reprompt() is simple. the examples below are bulky ## because they simulate various usage scenarios with commands, ## while in normal usage they would be due to editing. ## change to a temporary directory to avoid clogging up user's cur_wd <- getwd() tmpdir <- tempdir() setwd(tmpdir) ## as for prompt() the default is to save in current dir as "seq.Rd". ## the argument here is a function, reprompt finds its doc and ## updates all objects described along with `seq'. ## (In this case there is nothing to update, we have not changed `seq'.) fnseq <- reprompt(seq) ## let's parse the saved Rd file (the filename is returned by reprompt) rdoseq <- tools::parse_Rd(fnseq) # parse fnseq to see the result. Rdo_show(rdoseq) ## we replace usage statements with wrong ones for illustration. ## (note there is an S3 method along with the functions) dummy_usage <- char2Rdpiece(paste("seq()", "\\\\method{seq}{default}()", "seq.int()", "seq_along()", "seq_len()", sep="\n"), "usage") rdoseq_dummy <- Rdo_replace_section(rdoseq, dummy_usage) Rdo_show(rdoseq_dummy) # usage statements are wrong reprompt(rdoseq_dummy, file = "seqA.Rd") Rdo_show(tools::parse_Rd("seqA.Rd")) # usage ok after reprompt ## define function myseq() myseq <- function(from, to, x){ if(to < 0) { seq(from = from, to = length(x) + to) } else seq(from, to) } ## we wish to describe myseq() along with seq(); ## it is sufficient to put myseq() in the usage section ## and let reprompt() do the rest rdo2 <- Rdo_modify_simple(rdoseq, "myseq()", "usage") reprompt(rdo2, file = "seqB.Rd") # updates usage of myseq ## show the rendered result: Rdo_show(tools::parse_Rd("seqB.Rd")) ## Run this if you wish to see the Rd file: ## file.show("seqB.Rd") reprompt(infile = "seq.Rd", filename = "seq2.Rd") reprompt(infile = "seq2.Rd", filename = "seq3.Rd") ## Rd objects for installed help may need some tidying for human editing. #hseq_inst <- help("seq") #rdo <- utils:::.getHelpFile(hseq_inst) rdo <- Rdo_fetch("seq", "base") rdo rdo <- Rdpack:::.Rd_tidy(rdo) # tidy up (e.g. insert new lines # for human readers) reprompt(rdo) # rdo and rdoseq are equivalent all.equal(reprompt(rdo), reprompt(rdoseq)) # TRUE ## clean up unlink("seq.Rd") # remove temporary files unlink("seq2.Rd") unlink("seq3.Rd") unlink("seqA.Rd") unlink("seqB.Rd") setwd(cur_wd) # restore user's working directory unlink(tmpdir) } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{Rd} Rdpack/man/Rdo_append_argument.Rd0000644000175000017500000000323114013547052016627 0ustar nileshnilesh\name{Rdo_append_argument} \alias{Rdo_append_argument} \title{ Append an item for a new argument to an Rd object } \description{ Append an item for a new argument to an Rd object. } \usage{ Rdo_append_argument(rdo, argname, description = NA, indent = " ", create = FALSE) } \arguments{ \item{rdo}{an Rd object.} \item{argname}{name of the argument, a character vector.} \item{description}{description of the argument, a character vector.} \item{indent}{a string, typically whitespace.} \item{create}{not used (todo: remove?)} } \details{ Appends one or more items to the section describing arguments of functions in an Rd object. The section is created if not present. If \code{description} is missing or NA, a "todo" text is inserted. The inserted text is indented using the string \code{indent}. The lengths of \code{argname} and \code{description} should normally be equal but if \code{description} is of length one, it is repeated to achieve this when needed. } \value{ an Rd object } \author{Georgi N. Boshnakov} \examples{ ## the following creates Rd object rdo dummyfun <- function(x) x fn <- tempfile("dummyfun", fileext = ".Rd") reprompt(dummyfun, filename = fn) rdo <- tools::parse_Rd(fn) ## add documentation for arguments ## that are not in the signature of 'dummyfun()' dottext <- "further arguments to be passed on." dots <- paste0("\\\\", "dots") rdo2 <- Rdo_append_argument(rdo, dots, dottext, create = TRUE) rdo2 <- Rdo_append_argument(rdo2, "z", "a numeric vector") ## reprompt() warns to remove documentation for non-existing arguments: Rdo_show(reprompt(rdo2, filename = fn)) unlink(fn) } \keyword{RdoBuild} %\keyword{RdoElements} Rdpack/man/Rdo_modify.Rd0000644000175000017500000000704213501141722014744 0ustar nileshnilesh\name{Rdo_modify} \alias{Rdo_replace_section} \alias{Rdo_modify} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Replace or modify parts of Rd objects } \description{ Replace or modify parts of Rd objects. } \usage{ Rdo_modify(rdo, val, create = FALSE, replace = FALSE, top = TRUE) Rdo_replace_section(rdo, val, create = FALSE, replace = TRUE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object.} \item{val}{an Rd fragment.} \item{create}{if TRUE, create a new section, see `Details'.} \item{replace}{a logical, if TRUE \code{val} replaces the old content, otherwise \code{val} is concatenated with it, see `Details'. } \item{top}{a logical, if TRUE examine also the "Rd_tag" of \code{rdo}, see `Details'. } } \details{ Argument \code{rdo} is an Rd object (complete or a fragment) to be modified. \code{val} is an Rd fragment to use for modification. Basically, \code{val} is appended to (if \code{replace} is FALSE) or replaces (if \code{replace} is TRUE) the content of an element of \code{rdo} which has the same "Rd_tag" as \code{val}. Argument \code{top} specifies whether to check the "Rd_tag" of \code{rdo} itself, see below. Here are the details. If \code{top} is TRUE and \code{rdo} and \code{val} have the same (non-NULL) "Rd_tag", then the action depends on \code{replace} (argument \code{create} is ignored in this case). If \code{replace} is TRUE, \code{val} is returned. Otherwise \code{rdo} and \code{val} are, effectively, concatenated. For example, \code{rdo} may be the "arguments" section of an Rd object and \code{val} may also be an "arguments" section containing new arguments. Otherwise, an element with the "Rd_tag" of \code{val} is searched in \code{rdo} using \code{tools:::RdTags()}. If such elements are found, the action again depends on \code{replace}. \enumerate{ \item If \code{replace} is a character string, then the first element of \code{rdo} that is a list whose only element is identical to the value of \code{replace} is replaced by \code{val}. If such an element is not present and \code{create} is TRUE, \code{val} is inserted in \code{rdo}. If \code{create} is FALSE, \code{rdo} is not changed. \item If \code{replace} is TRUE, the first element found is replaced with \code{val}. \item If \code{replace} is FALSE, \code{val} is appended to the first element found. } If no element with the "Rd_tag" of \code{val} is found the action depends on \code{create}. If \code{create} is TRUE, then \code{val} is inserted in \code{rdo}, effectively creating a new section. If \code{create} is FALSE, an error is thrown. \code{Rdo_replace_section} is like \code{Rdo_modify} with argument \code{top} fixed to TRUE and the default for argument \code{replace} set to TRUE. It hardly makes sense to call \code{Rdo_replace_section} with \code{replace = FALSE} but a character value for it may be handy in some cases, see the examples. } \value{ an Rd object or fragment, as described in `Details' } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ # a <- tools::parse_Rd("./man/promptUsage.Rd") # char2Rdpiece("documentation", "keyword") # this changes a keyword from Rd to documentation # Rdo_replace_section(a, char2Rdpiece("documentation", "keyword"), replace = "Rd") } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoBuild} Rdpack/man/list_Rd.Rd0000644000175000017500000000350513501141722014251 0ustar nileshnilesh\name{list_Rd} \alias{list_Rd} %- Also NEED an '\alias' for EACH other topic documented here. \title{Combine Rd fragments} \description{Combine Rd fragments and strings into one object.} \usage{ list_Rd(..., Rd_tag = NULL, Rd_class = FALSE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{\dots}{named list of objects to combine, see `Details'.} \item{Rd_tag}{if non-null, a value for the \verb{Rd_tag} of the result.} \item{Rd_class}{logical; if TRUE, the result will be of class "Rd".} } \details{ The names of named arguments specify tags for the corresponding elements (not arbitrary tags, ones that are converted to macro names by prepending backslash to them). This is a convenient way to specify sections, items, etc, in cases when the arguments have not being tagged by previous processing. Character string arguments are converted to the appropriate Rd pieces. Argument \code{...} may contain a mixture of character vactors and Rd pieces. } \value{ an Rd object or list with \verb{Rd_tag} attribute, as specified by the arguments. } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{c_Rd}} } \examples{ ## see also the examples for c_Rd dummyfun <- function(x, ...) x u1 <- list_Rd(name = "Dummyname", alias = "dummyfun", title = "Dummy title", description = "Dummy description", usage = "dummyfun(x)", value = "numeric vector", author = "A. Author", Rd_class=TRUE ) Rdo_show(u1) # call reprompt to fill the arguments section (and correct the usage) fn <- tempfile("dummyfun", fileext = "Rd") reprompt(dummyfun, filename = fn) # check that the result can be parsed and show it. Rdo_show(tools::parse_Rd(fn)) unlink(fn) } \keyword{RdoBuild} Rdpack/man/Rdo_modify_simple.Rd0000644000175000017500000000206713501141722016317 0ustar nileshnilesh\name{Rdo_modify_simple} \alias{Rdo_modify_simple} %- Also NEED an '\alias' for EACH other topic documented here. \title{Simple modification of Rd objects} \description{Simple modification of Rd objects.} \usage{ Rdo_modify_simple(rdo, text, section, ...) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object.} \item{text}{a character vector} \item{section}{name of an Rd section, a string.} \item{\dots}{additional arguments to be passed to \code{Rdo_modify}.} } \details{ Argument \code{text} is used to modify (as a replacement of or addition to) the content of section \code{section} of \code{rdo}. This function can be used for simple modifications of an Rd object using character content without converting it separately to Rd. \code{text} is converted to Rd with \code{char2Rdpiece(text, section)}. The result is passed to \code{Rdo_modify}, together with the remaining arguments. } \value{ an Rd object } \author{Georgi N. Boshnakov} \seealso{ \code{\link{Rdo_modify}} } \keyword{RdoBuild} Rdpack/man/insert_all_ref.Rd0000644000175000017500000000457414200031006015636 0ustar nileshnilesh\name{insert_all_ref} \alias{insert_all_ref} \title{Insert references cited in packages} \description{Insert references cited in packages. } \usage{ insert_all_ref(refs, style = "") } \arguments{ \item{refs}{ % TODO: is this description up-to-date? a matrix specifying key-package pairs of the references to insert. Can also be a cached environment, see Details. } \item{style}{a bibstyle, see Details.} } \details{ \code{insert_all_ref} is the workhorse behind several Rd macros for inclusion of references in Rd documentation. Argument \code{refs} is a two-column character matrix. The first column specifies bibtex keys. To specify more than one key in a single element, separate them by commas. The second column specifies the package in which to look for the keys. A key equal to "*" requests all keys in the corresponding package. \code{insert_all_ref} drops duplicated keys, collects the references, and converts them to Rd textual representation for inclusion in Rd documentation files. \code{refs} can be a cached environment. This is for internal use and not documented. } \value{ for \code{insert_all_ref}, a character string containing a textual representation of the references, suitable for inclusion in an Rd file } \references{ Currently there are no citations. Nevethelese, I have put \verb{\insertAllCited{}} just after this paragraph to show the message that it prints when there are no citations. This seems better than printing nothing but it may be argued also that there should be a warning as well. \insertAllCited{} } \author{Georgi N. Boshnakov} % \note{ % %% ~~further notes~~ % } % % %% ~Make other sections like Warning with \section{Warning }{....} ~ % % \seealso{ % %% ~~objects to See Also as \code{\link{help}}, ~~~ % } \examples{ ## a reference from package Rdpack cat(insert_all_ref(matrix(c("Rpack:bibtex", "Rdpack"), ncol = 2)), "\n") ## more than one reference from package Rdpack, separate the keys with commas cat(insert_all_ref(matrix(c("parseRd,Rpack:bibtex", "Rdpack"), ncol = 2)), "\n") ## all references from package Rdpack cat(insert_all_ref(matrix(c("*", "Rdpack"), ncol = 2)), "\n") ## all references from package Rdpack and rbibutils m <- matrix(c("*", "Rdpack", "*", "rbibutils"), ncol = 2, byrow = TRUE) cat(insert_all_ref(m), "\n") } \keyword{documentation} % use one of RShowDoc("KEYWORDS") Rdpack/man/inspect_signatures.Rd0000644000175000017500000000334113501141722016560 0ustar nileshnilesh\name{inspect_signatures} \alias{inspect_signatures} \alias{inspect_clmethods} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Inspect signatures of S4 methods } \description{ Inspect signatures of S4 methods. } \usage{ inspect_clmethods(rdo, final = TRUE) inspect_signatures(rdo, package = NULL, sec = "Methods") } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object.} \item{package}{the name of a package, a character string or NULL.} \item{sec}{the name of a section to look into, a character string.} \item{final}{If not TRUE insert text with suggestions, otherwise comment the suggestions out. } } \details{ Signatures in documentation of S4 classes and methods are stored somewhat differently. \code{inspect_signatures} inspects signatures in documentation of methods of a function. \code{inspect_clmethods} inspects signatures in documentation of a class. \code{inspect_signatures} was written before \code{inspect_clmethods()} and was geared towards using existing code for ordinary functions (mainly \code{parse_usage_text()}. If new methods are found, the functions add entries for them in the Rd object \code{rdo}. If \code{rdo} documents methods that do not exist, a message inviting the user to remove them manually is printed but the offending entries remain in the object. At the time of writing, \verb{R CMD check} does not warn about this. } \value{ an Rd object } \note{todo: need consolidation.} \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoS4} Rdpack/man/S4formals.Rd0000644000175000017500000000276713501141722014534 0ustar nileshnilesh\name{S4formals} \alias{S4formals} \title{Give the formal arguments of an S4 method} \description{Give the formal arguments of an S4 method.} \usage{ S4formals(fun, \dots) } \arguments{ \item{fun}{name of an S4 generic, a string, or the method, see Details.} \item{\dots}{further arguments to be passed to \code{getMethod}, see Details.} } \details{ \code{S4formals} gives the formal arguments of the requested method. If \code{fun} is not of class \code{methodDefinition}, it calls \code{getMethods}, passing on all arguments. Typically, \code{fun} is the name of a generic function and the second argument is the signature of the method as a character vector. Alternatively, \code{fun} may be the method itself (e.g. obtained previously from \code{getMethod}) and in that case the \verb{"\dots"} arguments are ignored. See \code{\link{getMethod}} for full details and other acceptable arguments. } \value{ a pairlist, like \code{\link{formals}} } \note{ Arguments of a method after those used for dispatch may be different from the arguments of the generic. The latter may simply have a \verb{"\dots"} argument there. todo: there should be a similar function in the "methods" package, or at least use a documented feature to extract it. } \author{ Georgi N. Boshnakov } \examples{ require(stats4) # makes plot() S4 generic S4formals("plot", c(x = "profile.mle", y = "missing")) m1 <- getMethod("plot", c(x = "profile.mle", y = "missing")) S4formals(m1) } \keyword{methods} Rdpack/man/Rdo_fetch.Rd0000644000175000017500000000633013501141722014545 0ustar nileshnilesh\name{Rdo_fetch} \alias{Rdo_fetch} %- Also NEED an '\alias' for EACH other topic documented here. \title{Get help pages as Rd objects} \description{ Get a help page as an Rd object from an installed or source package. } \usage{ Rdo_fetch(Rd_name = character(0), package, dir = ".", installed = TRUE) } \arguments{ \item{Rd_name}{ names of one or more Rd help pages. \code{name} here is the name of an Rd file stripped from the extension. } \item{package}{ the package from which to get the Rd object, a character string. } \item{dir}{ a character string giving the root directory of a source package. Used only if \code{package} is missing. } \item{installed}{ if \code{TRUE}, the default, the Rd object is taken unconditionally from the installed \code{package}. If \code{FALSE}, the help page may be taken from a source tree, if appropriate (typically if \code{package} is in `developer's mode under devtools, see Details). } } \details{ If \code{Rd_name} is a character string (typical use case), the corresponding help page is returned as an object from class \code{"Rd"}. If the length of \code{Rd_name} is greater than one, the result is a Rd_named list containing the corresponding \code{"Rd"} objects. The default \code{Rd_name = character(0)} requests all Rd pages in the package. Note that \code{Rd_name} does not contain the extention \code{".Rd"} but the names in the returned list do. Argument \code{package} names the package from which to fetch the documentation object. With the default \code{installed = TRUE} the object is taken unconditionally from the installed package. To get it from the source tree of a package, use argument \code{"dir"} instead. The default, \code{""}, for \code{dir} is suitable for workflows where the working directory is the root of the desired package. Argument \code{installed} concerns primarily development under package \code{"devtools"}. \code{"devtools"} intercepts and modifies several base \R commands, concerning access to system files and getting help, with the aim of rerouting them to the source trees of packages under developer's mode. If argument \code{installed} is \code{TRUE}, the default, the requested pages are taken from the installed package, even if it is in development mode. If argument \code{installed} is \code{FALSE}, the Rd objects are taken from the corresponding source tree, if the specified package is under developer's mode, and from the installed package otherwise. Argument \code{Rd_name} is the name used in the \code{\\name} section of Rd files. When working off the source tree of a package, \code{Rdo_fetch} processes the Rd files, so \code{roxygen2} users need to update them if necessary. } \value{ if \code{length(Rd_name) = 1}, an object of class \code{"Rd"}, otherwise a list of \code{"Rd"} objects. } \author{Georgi N. Boshnakov} %\seealso{ %%% ~~objects to See Also as \code{\link{help}}, ~~~ %} \examples{ ## get a single help page rdo <- Rdo_fetch("viewRd", package = "Rdpack") Rdo_show(rdo) ## get a list of help pages rdo <- Rdo_fetch(c("viewRd", "reprompt"), package = "Rdpack") names(rdo) } \keyword{documentation} % use one of RShowDoc("KEYWORDS") Rdpack/man/Rdo_macro.Rd0000644000175000017500000000504413501141722014556 0ustar nileshnilesh\name{Rdo_macro} \alias{Rdo_macro} \alias{Rdo_macro1} \alias{Rdo_macro2} \alias{Rdo_item} \alias{Rdo_sigitem} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Format Rd fragments as macros (todo: a baffling title!) } \description{ Format Rd fragments as macros, generally by putting them in a list and setting the "Rd_tag" as needed. } \usage{ Rdo_macro(x, name) Rdo_macro1(x, name) Rdo_macro2(x, y, name) Rdo_item(x, y) Rdo_sigitem(x, y, newline = TRUE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{x}{an object.} \item{y}{an object.} \item{name}{the "\verb{Rd_tag}", a string.} \item{newline}{currently ignored.} } \details{ \code{Rdo_macro1} wraps \code{x} in a list with "\verb{Rd_tag}" \code{name}. This is the representation of Rd macros with one argument. \code{Rdo_macro2} basically wraps a possibly transformed \code{x} and \code{y} in a list with "\verb{Rd_tag}" \code{name}. More specifically, if \code{x} has a non-NULL "\verb{Rd_tag}", \code{x} is wrapped in \code{list}. Otherwise \code{x} is left as is, unless \code{x} is a character string, when it is converted to a text Rd element and wrapped in \code{list}. \code{y} is processed in the same way. This is the representation of Rd macros with two arguments. \code{Rdo_macro} returns an object with "\verb{Rd_tag}" \code{name}, constructed as follows. If \code{x} is not of class "character", its attribute "\verb{Rd_tag}" is set to \code{name} and the result returned without further processing. Otherwise, if it is of class "character", \code{x} is tagged as an Rd "TEXT" element. It is then wrapped in a list but only if \code{name} is one of "\verb{\eqn}" or "\verb{\deqn}". Finally, \code{Rdo_macro1} is called on the transformed object. \code{Rdo_item} is equivalent to \code{Rdo_macro2} with \code{name} set to "\verb{\item}". \code{Rdo_sigitem} is for items which have the syntax used in description of signatures. In that case the first argument of "\verb{\item}" is wrapped in "\verb{\code}". If \code{y} is missing, a text inviting the author to provide a description of the function for this signature is inserted. } \value{ An Rd element with appropriately set \verb{Rd_tag}, as described in `Details'. } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{RdoProgramming} %\keyword{RdoElements} \keyword{RdoBuild} Rdpack/man/Rdo_get_item_labels.Rd0000644000175000017500000000223213501141722016570 0ustar nileshnilesh\name{Rdo_get_item_labels} \alias{Rdo_get_item_labels} \title{Get the labels of items in an Rd object} \description{Get the labels of items in an Rd object.} \usage{ Rdo_get_item_labels(rdo) } \arguments{ \item{rdo}{an Rd object.} } \details{ \code{Rdo_get_item_labels(rdo)} gives the labels of all \code{"\item"}s in \code{rdo}. Argument \code{rdo} is often a section or other Rd object fragment, see the examples. } \value{ a character vector } \author{Georgi N. Boshnakov} \examples{ infile <- system.file("examples", "tz.Rd", package = "Rdpack") rd <- tools::parse_Rd(infile) ## get item labels found anywhere in the Rd object (items <- Rdo_get_item_labels(rd)) ## search only in section "arguments" (i.e., get argument names) ## (note [[1]] - there is only one arguments section) pos.args <- Rdo_locate_core_section(rd, "\\\\arguments")[[1]] (args <- Rdo_get_item_labels(rd[[pos.args$pos]])) ## search only in section "value" pos.val <- Rdo_locate_core_section(rd, "\\\\value")[[1]] (vals <- Rdo_get_item_labels(rd[[pos.val$pos]])) ## There are no other items in 'rd', so this gives TRUE: all.equal(items, c(args, vals)) # TRUE } \keyword{RdoProgramming} Rdpack/man/inspect_usage.Rd0000644000175000017500000000261113501141722015477 0ustar nileshnilesh\name{inspect_usage} \alias{inspect_usage} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Inspect the usage section in an Rd object } \description{ Inspect the usage section in an Rd object. } \usage{ inspect_usage(rdo) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object.} } \details{ The usage section in the Rd object, \code{rdo}, is extracted and parsed. The usage of each function described in \code{rdo} is obtained also from the actual installed function and compared to the one from \code{rdo}. The return value is a list, with one element for each function usage as returned by \code{compare_usage1}. One of the consequences of this is that an easy way to add a usage description of a function, say \code{fu} to an existing Rd file is to simply add a line \code{fu()} to the usage section of that file and run \code{reprompt} on it. } \value{ a list of comparison results as described in `Details' (todo: give more details here) } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{inspect_args}} } % \examples{ % ##---- Should be DIRECTLY executable !! ---- % } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{ ~kwd1 } \keyword{RdoUsage} %\keyword{RdFunction} Rdpack/man/Rdpack-package.Rd0000644000175000017500000004207113756515650015470 0ustar nileshnilesh\name{Rdpack-package} \alias{Rdpack-package} \alias{Rdpack} \docType{package} \title{ \Sexpr[stage=build,results=hide]{require(Rdpack)} \Sexpr[stage=build,results=hide]{pd <- utils::packageDescription("Rdpack")} \Sexpr[stage=build,results=hide]{lb <- library(help="Rdpack", character.only=TRUE)} \Sexpr[stage=build]{pd$Title} } \description{ \Sexpr[stage=build]{pd$Description} } \details{ \tabular{ll}{ Package: \tab \Sexpr[stage=build]{pd$Package}\cr Type: \tab \Sexpr[stage=build]{pd$Type}\cr Version: \tab \Sexpr[stage=build]{pd$Version} \cr Date: \tab \Sexpr[stage=build]{pd$Date}\cr License: \tab \Sexpr[stage=build]{pd$License}\cr LazyLoad: \tab \Sexpr[stage=build]{pd$LazyLoad}\cr Built: \tab \Sexpr[stage=build]{pd$Built} } % % 2018-05-24 commenting out % Index: % % \Sexpr[stage=build,results=rd]{paste("\\\\preformatted{", paste(if(!is.null(lb$info[[2]])) lb$info[[2]] else "No entries",collapse="\\n"), "}", sep="")} % % Package \code{Rdpack} provides a number of functions for maintenance of documentation in \R packages. Although base \R and package \code{methods} have functions for creation of skeleton documentation, if a function gets a new argument or a generic gets a new method, then updating existing documentation is somewhat inconvenient. This package provides functions that update parts of the Rd documentation that can be dealt with automatically and leave manual changes untouched. For example, usage sections for functions are updated and if there are undescribed arguments, additional items are put in the `arguments' section. A set of functions and macros support inclusion of references and citations from BibTeX files in \R documentation (Rd and roxygen2). These tools use only facilities provided by base \R and package \pkg{rbibutils} \insertCite{Rpackage:rbibutils}{Rdpack}. There are also convenience macros for inclusion of evaluated examples and graphs, which hide some of the hassle of doing this directly with the underlying \verb{\Sexpr}'s. The subsections below give additional details, see also the vignettes. \subsection{Creating and updating Rd files}{ The main function provided by this package is \code{\link{reprompt}}. There is also a function \code{\link{promptPackageSexpr}} for creating initial skeleton for overall package description such as this help page. \code{\link{reprompt}} produces a skeleton documentation for the requested object, similarly to functions like \code{prompt}, \code{promptMethods}, and \code{promptClass}. Unlike those functions, \code{\link{reprompt}} updates existing documentation (installed or in an Rd object or file) and produces a skeleton from scratch as a last resort only. If the documentation object describes more than one function, all descriptions are updated. Basically, \code{\link{reprompt}} updates things that are generated automatically, leaving manual editing untouched. The typical use of \code{reprompt} is with one argument, as in \preformatted{ reprompt(infile = "./Rdpack/man/reprompt.Rd") reprompt(reprompt) reprompt("reprompt") } \code{reprompt} updates the documentation of all objects described in the Rd object or file, and writes the updated Rd file in the current working directory, see \code{\link{reprompt}} for details. To describe a new function in an existing Rd file, just add something like \code{myfun()} and run reprompt to insert the correct signature, alias, etc. This works also for replacement functions, see \code{\link{reprompt}} for details. \code{\link{ereprompt}} updates the Rd documentation in a file, overwrites it and opens it in an editor. It calls \code{reprompt} to do the actual job but has different defaults. Which editor is opened, is system dependent, see the \code{\link[utils]{edit}} and \code{\link{ereprompt}} for futher details. Users who work on Rd files in RStudio can use add-in \dQuote{Reprompt} to invoke \code{reprompt} conveniently on an Rd file or on a selected object in an \R source code file, see \code{\link{RStudio_reprompt}}. This add-in was contributed by Duncan Murdoch. Users of Emacs/ESS have various options, depending on their workflow. One approach is to define a key to call \code{\link{ereprompt}} on the file being edited, see \href{https://github.com/GeoBosh/georgisemacs}{georgisemacs} for an example setup. \code{\link{promptPackageSexpr}} creates a skeleton for a package overview in file \verb{name-package.Rd}. Then the file can be edited as needed. This function needs to be called only once for a package since automatic generation of information in \verb{name-package.Rd} is achieved with Sexpr's at build time, not with verbatim strings (\code{promptPackage} used to insert verbatim strings but in recent versions of \R it also uses macros.). For example, the source of this help page is file `Rdpack-package.Rd'. It was initially produced using \preformatted{ promptPackageSexpr("Rdpack") } The factual information at the beginning of this help topic (the index above, the version and other stuff that can be determined automatically) is kept automatically up to date. } \subsection{References and Citations}{ Another set of functions is for management of bibliographic references in Rd files. The old approach based on function \code{\link{rebib}} is fully functional, see below, but the recommended way to insert references and citations is based on Rd macros. The provided Rd macros are fully portable and, in particular, work in Rd files and roxygen2 comments, see \code{\link{insertRef}} and vignette \code{vignette("Inserting_bibtex_references", "Rdpack")} for details and examples. The Bibtex source for the references and citations produced by the Rd macros is file "REFERENCES.bib", which should be located in the root of the package installation directory. \pkg{Rdpack} needs also to be mentioned in two places in file `DESCRIPTION'. These one-off preparation steps are enumerated below: \enumerate{ \item{ Put the following line in file `DESCRIPTION': \cr \verb{RdMacros: Rdpack} \cr (If there is already a line starting with 'RdMacros:', add \pkg{Rdpack} to the list on that line.) } \item{ Add \pkg{Rdpack} to the list of imports (\verb{Imports:} field) in file `DESCRIPTION'. } \item{ Add the following line to file `NAMESPACE': \preformatted{ importFrom(Rdpack,reprompt) } Alternatively, if \pkg{devtools} is managing your NAMESPACE file, the equivalent \pkg{roxygen2} line is: \preformatted{ #' @importFrom Rdpack reprompt} } \item{ Create file \code{"REFERENCES.bib"} in subdirectory \code{"inst/"} of the package and put the BibTeX references in that file. } } The Rd macro \code{\\insertRef} takes two arguments: a BibTeX key and the name of a package. Thus, \code{\\insertRef{key}{package}} inserts the reference whose key is \code{key} from "REFERENCES.bib" of the specified package (almost always the one being documented). % With \pkg{Rdpack (>= 0.6-1)}, Citations can be done with Rd macro \code{\\insertCite}, which inserts citation(s) for one or more BibTeX keys and records the keys. \code{\\insertCiteOnly} is similar to \code{\\insertCite} but does not record the keys. \code{\\insertNoCite} records the keys but does not produce citations. \code{\\insertAllCited} creates a bibliography including all references recorded by \code{\\insertCite} and \code{\\insertNoCite}. It is usually put in section \dQuote{References}, something like: \preformatted{ \references{ \insertAllCited{} } } in an Rd file. Don't align the backslash with the second 'e' of \code{@references}, since roxygen2 may interpret it as verbatim text, not macro. The analogous documentation chunk in roxygen2 might look like this: \preformatted{ #' @references #' \insertAllCited{} } Bibliography styles for lists of references are supported as well. Currently the only alternative offered is to use long names (Georgi N. Boshnakov) in place of the default style (Boshnakov GN). More comprehensive alternatives can be included if needed or requested. Convenience functions \code{\link{makeVignetteReference}} and \code{\link{vigbib}} generate Bibtex entries for vignettes. } \subsection{Previewing documentation pages}{ It is convenient during development to be able to view the rendered version of the document page being edited. The function \code{\link{viewRd}} renders a documentation file in a source package and displays it as text or in a browser. It renders references properly in any workflow, including \pkg{devtools} development mode \insertCite{Rdevtools}{Rdpack} in Emacs/ESS, Rstudio, Rgui. This function is a good candidate to be assigned to a key in editors which support this. I created this function (in 2017) since the functions provided by \pkg{devtools} and Emacs/ESS are giving errors when processing pages containing Rd macros. } \subsection{Static Management of References}{ In the alternative approach, the function \code{\link{rebib}} updates the bibliographic references in an Rd file. Rdpack uses a simple scheme for inclusion of bibliographic references. The key for each reference is in a TeX comment line, as in: \preformatted{ \references{ ... \% bibentry: key1 \% bibentry: key2 ... } } \code{rebib} puts each reference after the line containing its key. It does nothing if the reference has been put by a previous call of \code{rebib}. If the Bibtex entry for some references changes, it may be necessary to update them in the Rd file, as well. Call \code{rebib} with \code{force = TRUE} to get this effect. There is also a facility to include all references from the Bibtex file, see the documentation of \code{\link{rebib}} for details. } \subsection{Inserting evaluated examples}{ Sometimes the documentation of an object becomes more clear if accompanied by snippets of R code and their results. The standard Rd macro \verb{\Sexpr} caters for a number of possibilities to evaluate \R code and insert the results and the code in the documentation. The Rd macro \verb{\printExample} provided by package \pkg{Rdpack} builds on it to print a snippet of \R code and the results of its evaluation, similarly to console output but the code is not prefixed and the results are prefixed with comment symbols. For example, \verb{\printExample{2+2; a <- 2*3; a}} produces the following in the rendered documentation: \printExample{2+2; a <- 2*3; a} The help page of \code{\link{promptUsage}} contains a number of examples created with \code{\\printExample}. The corresponding Rd file can be obtained from the package tarball or from \url{https://github.com/GeoBosh/Rdpack/blob/master/man/promptUsage.Rd}. The argument of \verb{\printExample} must be on a single line with versions of R before R 3.6.0. \verb{\printExample} is typically placed in section Details of an object's documentation, see section Details of \code{\link{get_usage}} for anumber of examples produced mostly with \verb{\printExample}. The macro \verb{\runExamples} can be used as a replacement of section \verb{Examples}. For example, if the following code is put at the top level in an Rd file (i.e. not in a section): \preformatted{ \runExamples{2+2; a <- 2*3; a} } then it will be evaluated and replaced by a normal section examples: \preformatted{ \examples{ 2 + 2 ##: 4 a <- 2 * 3 a ##: 6 } } This generated examples section is processed by the standard \R tools (almost) as if it was there from the outset. In particular, the examples are run by the R's quality control tools and tangled along with examples in other documentation files. In \R versions before 3.6.0 \verb{R CMD check} used to give a warning about unknown \verb{\Sexpr} section at top level. % According to the specification of the Rd format, \insertCite{@see @parseRd, % p. 4;textual}{Rdpack} \verb{\Sexpr} at top level is legal but I need to check with the CRAN % team or R devel if such expressions produced by user macros are excluded on purpose. } \subsection{Creating and including graphs}{ Figures can be inserted with the help of the standard Rd markup command \verb{\figure}. The Rd macro \verb{\insertFig} provided by package \pkg{Rdpack} takes a snipped of \R code, evaluates it and inserts the plot produced by it (using \verb{\figure}). \verb{\insertFig} takes three arguments: a filename, the package name and the code to evaluate to produce the figure. For example, \preformatted{ \insertFig{cars.png}{mypackage}{x <- cars$speed; y <- cars$dist; plot(x,y)} } will evaluate the code, save the graph in file \code{"man/figures/cars.png"} subdirectory of package \code{"mypackage"}, and include the figure using \verb{\figure}. Subdirectory \code{"figures"} is created if it doesn't exist. Currently the graphs are saved in \code{"png"} format only. In older versions of \R the code should be on a single line for the reasons explained in the discussion of \verb{\printExample}. The sister macro \verb{\makeFig} creates the graph in exactly the same way as \verb{\insertFig} but does not insert it. This can be done with a separate \verb{\figure} command. This can be used if additional options are desired for different output formats, see the description of \verb{\figure} in "Writing R extensions". } Other functions that may be useful are \code{Rdo2Rdf}, \code{Rdapply} and \code{Rd_combo}. Here is also brief information about some more technical functions that may be helpful in certain circumstances. \code{\link{get_usage}} generates usage text for functions and methods. The functions can be located in environments or other objects. This may be useful for description of function elements of compound objects. \code{\link{c_Rd}} concatenates Rd pieces, character strings and lists to create a larger Rd piece or a complete Rd object. \code{\link{list_Rd}} is similar to \code{\link{c_Rd}} but provides additional features for convenient assembling of Rd objects. \code{\link{parse_Rdpiece}} is a technical function for parsing pieces of Rd source text but it has an argument to return formatted help text which may be useful when one wishes to show it to the user. \code{Rdo_set_section} can be used to set a section, such as "\verb{\author}". The remaining functions in the package are for programming with Rd objects. } \author{ \Sexpr[stage=build]{pd$Author} Maintainer: \Sexpr[stage=build]{pd$Maintainer} } \note{ All processing is done on the parsed Rd objects, i.e. objects of class "Rd" or pieces of such objects \insertCite{parseRd}{Rdpack}. The following terminology is used (todo: probably not yet consistently) throughout the documentation. "Rd object" - an object of class Rd, or part of such object. "Rd piece" - part of an object of class Rd. Fragment is also used but note that \code{parse_Rd} defines fragment more restrictively. "Rd text", "Rd source text", "Rd format" - these refer to the text of the Rd files. } \seealso{ % \code{\link[:-package]{}} ~~ \code{\link{ereprompt}}, \code{\link{reprompt}}, \code{\link{promptPackageSexpr}}, \code{\link{rebib}}, \code{\link{get_usage}}, \code{\link{viewRd}}, \code{\link{vigbib}}, \code{\link{makeVignetteReference}}, \code{vignette("Inserting_bibtex_references", package = "Rdpack")}, \code{vignette("Inserting_figures_and_evaluated_examples", package = "Rdpack")} } \references{ \strong{Note:} Reference \insertCite{dummyArticle;textual}{Rdpack} does not exist. It is a test that simple math in BibTeX entries works. --- \insertAllCited{} } \examples{ ## The examples below show typical use but are not executable. ## For executable examples see the help pages of ## reprompt, promptPackageSexpr, and rebib. ## To make the examples executable, replace "myfun" with a real ## function, and similarly for classes and paths to files. \dontrun{ ## update the doc. from the Rd source and save myfun.Rd ## in the current directory (like prompt) reprompt(infile="path/to/mypackage/man/myfun.Rd") ## update doc of myfun() from the installed doc (if any); ## if none is found, create it like prompt reprompt("myfun") reprompt(myfun) # same ## update doc. for S4 methods from Rd source reprompt(infile="path/to/mypackage/man/myfun-methods.Rd") ## update doc. for S4 methods from installed doc (if any); ## if none is found, create it like promptMethods reprompt("myfun", type = "methods") reprompt("myfun-methods") # same ## update doc. for S4 class from Rd source reprompt(infile="path/to/mypackage/man/myclass-class.Rd") ## update doc. of S4 class from installed doc. ## if none is found, create it like promptClass reprompt("myclass-class") reprompt("myclass", type = "class") # same ## create a skeleton "mypackage-package.Rd" promptPackageSexpr("mypackage") ## update the references in "mypackage-package.Rd" rebib(infile="path/to/mypackage/man/mypackage-package.Rd", force=TRUE) } } \keyword{ package } Rdpack/man/parse_Rdtext.Rd0000644000175000017500000000362713501141722015322 0ustar nileshnilesh\name{parse_Rdtext} \alias{parse_Rdtext} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Parse Rd source text as the contents of a section } \description{ Parse Rd source text as the contents of a given section. } \usage{ parse_Rdtext(text, section = NA) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{text}{Rd source text, a character vector.} \item{section}{the section name, a string.} } \details{ If \code{section} is given, then \code{parse_Rdtext} parses \code{text} as appropriate for the content of section \code{section}. This is achieved by inserting \code{text} as an argument to the TeX macro \code{section}. For example, if \code{section} is "\verb{\usage}", then a line "\verb{\usage\{}" is inserted at the begiinning of \code{text} and a closing "\verb{\}}" at its end. If \code{section} is NA then \code{parse_Rdtext} parses it without preprocessing. In this case \code{text} itself will normally be a complete section fragment. } \value{ an Rd fragment } \author{Georgi N. Boshnakov} \note{ The text is saved to a temporary file and parsed using \code{parse_Rd}. This is done for at least two reasons. Firstly, \code{parse_Rd} works most reliably (at the time of writing this) from a file. Secondly, the saved file may be slightly different (escaped backslashes being the primary example). It would be a nightmare to ensure that all concerned functions know if some Rd text is read from a file or not. The (currently internal) function \code{.parse_Rdlines} takes a character vector, writes it to a file (using \code{cat}) and calls \code{parse_Rd} to parse it. } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{parse_Rdpiece}} } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoProgramming} Rdpack/man/Rdo_get_insert_pos.Rd0000644000175000017500000000300313501141722016472 0ustar nileshnilesh\name{Rdo_get_insert_pos} \alias{Rdo_get_insert_pos} \title{ Find the position of an "Rd_tag" } \description{ Find the position of an "Rd_tag". } \usage{ Rdo_get_insert_pos(rdo, tag) } \arguments{ \item{rdo}{an Rd object} \item{tag}{the "Rd_tag" to search for, a string} } \details{ This function returns a position in \code{rdo}, where the next element carrying "Rd_tag" \code{tag} should be inserted. The position is determined as follows. If one or more elements of \code{rdo} have "Rd_tag" \code{tag}, then the position is one plus the position of the last such element. If there are no elements with "Rd_tag" \code{tag}, the position is one plus the length of \code{rdo}, unless \code{tag} is a known top level Rd section. In that case, the position is such that the standard ordering of sections in an Rd object is followed. This is set in the internal variable \code{.rd_sections}. } \value{ an integer } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ #h <- help("Rdo_macro") #rdo <- utils:::.getHelpFile(h) rdo <- Rdo_fetch("Rdo_macro", "Rdpack") ialias <- which(tools:::RdTags(rdo) == "\\\\alias") ialias next_pos <- Rdo_get_insert_pos(rdo, "\\\\alias") # 1 + max(ialias) next_pos stopifnot(next_pos == max(ialias) + 1) ikeyword <- which(tools:::RdTags(rdo) == "\\\\keyword") ikeyword next_pos <- Rdo_get_insert_pos(rdo, "\\\\keyword") # 1 + max(ikeyword) next_pos stopifnot(next_pos == max(ikeyword) + 1) } \keyword{RdoProgramming} Rdpack/man/parse_usage_text.Rd0000644000175000017500000000265413501141722016217 0ustar nileshnilesh\name{parse_usage_text} \alias{parse_usage_text} \alias{parse_1usage_text} \title{ Parse usage text } \description{ Parse usage text. } \usage{ parse_1usage_text(text) parse_usage_text(text) } \arguments{ \item{text}{ conceptually, the content of the usage section of one or more Rd objects, a character vector, see Details. } } \details{ For \code{parse_usage_text}, \code{text} is a character vector representing the contents of the usage section of an Rdo object. \code{parse_usage_text} does some preprocessing of \code{text} then calls \code{parse_1usage_text} for each usage statement. The preprocessing changes "\verb{\\}\verb{dots}" to "\verb{...}" and converts S3- and S4-method descriptions to a form suitable for \code{parse()}. The text is then parsed (with \code{parse}) and "\verb{srcref}" attribute removed from the parsed object. todo: currently no checks is made for Rd comments in \code{text}. \code{parse_1usage_text} processes the usage statement of one object and calls \code{\link{pairlist2f_usage1}} to convert it to an object from S3 class \code{"f_usage"}. } \value{ for \code{parse_1usage_text}, an object from S3 class \code{"f_usage"}, see \code{\link{pairlist2f_usage1}} for its structure. for \code{parse_usage_text}, a list containing one element for each usage entry, as prepared by \code{parse_1usage_text} } \author{Georgi N. Boshnakov} \keyword{RdoUsage} Rdpack/man/predefined.Rd0000644000175000017500000000551413501141722014760 0ustar nileshnilesh\name{predefined} \alias{Rdo_predefined_sections} \alias{Rdo_piece_types} \alias{rdo_top_tags} \title{ Tables of predefined sections and types of pieces of Rd objects } \description{ Tables of predefined sections and types of pieces of Rd objects. } \usage{ Rdo_predefined_sections Rdo_piece_types rdo_top_tags } \details{ The Rd syntax defines several tables \insertCite{parseRd}{Rdpack}. \pkg{Rdpack} stores them in the variables described here. \code{Rdo_predefined_sections} is a named character vector of types of the top level sections of an Rd object. \code{Rdo_piece_types} is a named character vector giving the types of the core (all possible?) Rd macros. \strong{NOTE:} These objects are hard coded and need to be updated if the specifications of the Rd format are updated. todo: write functions that go through existing Rd documentation to discover missing or wrong items. } \value{ for \code{Rdo_predefined_sections}, the name-value pairs are given in the following table. For example, \code{Rdo_predefined_sections["examples"]} is \Sexpr[stage=build,results=rd]{Rdo_predefined_sections["examples"]}. \Sexpr[stage=build,results=rd]{require(Rdpack); paste( "\\\\ifelse{latex}{\\\\out{", "\\\\begin{tabular}{ll|lll}", paste(names(Rdo_predefined_sections)[1:5], Rdo_predefined_sections[1:5], " ", names(Rdo_predefined_sections)[-(1:5)], Rdo_predefined_sections[-(1:5)], sep=" & ", collapse="\\\\\\\\\\\\\\\\ \n"), "\\\\end{tabular}", "}}{", "\\\\tabular{lllll}{", paste(names(Rdo_predefined_sections)[1:5], Rdo_predefined_sections[1:5], " | ", names(Rdo_predefined_sections)[-(1:5)], Rdo_predefined_sections[-(1:5)], sep=" \\\\tab ", collapse="\\\\cr\n"), "}", "}" )} for \code{Rdo_piece_types}, the name-value pairs are: \Sexpr[stage=build,results=rd]{ paste( "\\\\ifelse{latex}{\\\\out{", "\\\\begin{tabular}{ll|ll|ll|ll|ll|ll}", paste(names(Rdo_piece_types), " & ", Rdo_piece_types, c(rep(" & ",2),"\\\\\\\\\\\\\\\\"), sep="", collapse="\n"), "\\\\end{tabular}", "}}{", "\\\\tabular{llllllllllll}{", paste(names(Rdo_piece_types), "\\\\tab ", Rdo_piece_types, c(rep(paste("\\\\tab ", "|", sep=""),2), "\\\\cr"), sep="", collapse="\n"), "}", "}" )} for \code{rdo_top_tags}, the values are: \Sexpr[stage=build,results=rd]{ paste("\\\\tabular{lllll}{", paste(sub("^[#]", "\\\\\\\\verb{#}", sub("^([\\\\])", "{\\\\\\\\\\\\1}", rdo_top_tags)), c(rep("\\\\tab ",4),"\\\\cr"), sep="", collapse="\n"), "}")} Note that most, but not all, are prefixed with backaslash. } \references{ \insertAllCited{} } \keyword{Rd} Rdpack/man/Rdo2Rdf.Rd0000644000175000017500000001022414200243422014104 0ustar nileshnilesh\name{Rdo2Rdf} \alias{Rdo2Rdf} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Convert an Rd object to Rd file format } \description{ Converts an Rd object to Rd format and saves it to a file or returns it as a character vector. It escapes percents where necessary and (optionally) backslashes in the examples section. } \usage{ Rdo2Rdf(rdo, deparse = FALSE, ex_restore = FALSE, file = NULL, rcode = TRUE, srcfile = NULL) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object or a character vector, see `Details'.} \item{deparse}{logical, passed to the print method for Rd objects, see `Details'. } \item{ex_restore}{logical, if \code{TRUE} escapes backslashes where necessary. } \item{file}{a filename where to store the result. If \code{NULL} or "missing", the result is returned as a character vector. } \item{rcode}{if TRUE, duplicate backslahes in RCODE elements, see Details. } \item{srcfile}{NULL or a file name, see 'Details'.} } \details{ The description here is rather technical and incomplete. In any case it concerns almost exclusively Rd files which use escape sequences containing multiple consecutive backslashes or escaped curly braces (such things appear in regular expressions, for example). In principle, this function should be redundant, since the \code{print} and \code{as.character} methods for objects of class "Rd" would be expected to do the job. I was not able to get the desired result that way (the \code{deparse} option to \code{print} did not work completely for me either). Arguments \code{ex_restore} and \code{rcode} were added on an ad-hoc basis. \code{rcode} is more recent and causes \code{Rdo2Rdf} to duplicate backslashes found in any element \code{Rd_tag}-ed with "RCODE". \code{ex_restore} does the same but only for the examples section. In effect, if \code{rcode} is TRUE, \code{ex_restore} is ignored. The initial intent of this function (and the package Rdpack as a whole was not to refer to the Rd source file. However, there is some flexibility in the Rd syntax that does not allow the source file to be restored identically from the parsed object. This concerns mainly backslahes (and to some extent curly braces) which in certain contexts may or may not be escaped and the parsed object is the same. Although this does not affect functionality, it may be annoying if the escapes in sections not examined by \code{reprompt} were changed. If \code{srcfile} is the name of a file, the file is parsed and the Rd text of sections of \code{rdo} that are identical to sections from \code{srcfile} is taken directly from \code{srcfile}, ensuring that they will be identical to the original. } \value{ \code{NULL}, if \code{file} is not \code{NULL}. Otherwise the Rd formatted text as a character vector. } \author{Georgi N. Boshnakov} \note{ Here is an example when the author's Rd source cannot be restored exactly from the parsed object. In the Rd source "author" has two backslashes here: \verb{\\author}. In the Rd source "author" has one backslash here: \verb{\author}. Both sentences are correct and the parsed file contains only one backslash in both cases. If \code{reprompt} looks only at the parsed object it will export one backslash in both cases. So, further reprompt()-ing will not change them again. This is if \code{reprompt} is called with \code{sec_copy = FALSE}. With the default \code{sec_copy = TRUE}, \code{reprompt} calls \code{Rdo2Rdf} with argument \code{srcfile} set to the name of the Rd file and since \code{reprompt} does not modify section "Note", its text is copied from the file and the author's original preserved. However, the arguments of \verb{\eqn} are parse_Rd-ed differently (or so it seems) even though they are also in verbatim. } %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ # # this keeps the backslashes in "author" (see Note above) # reprompt(infile="./man/Rdo2Rdf.Rd") # # this outputs "author" preceded by one backslash only. # reprompt(infile="./man/Rdo2Rdf.Rd", sec_copy = FALSE) } \keyword{Rd} Rdpack/man/promptPackageSexpr.Rd0000644000175000017500000000665513501141722016501 0ustar nileshnilesh\name{promptPackageSexpr} \alias{promptPackageSexpr} %- Also NEED an '\alias' for EACH other topic documented here. \title{Generates a shell of documentation for an installed package} \description{ Generates a shell of documentation for an installed package. The content is similar to `promptPackage' but information that can be computed is produced with Sexpr's so that it is always up to date. } \usage{ promptPackageSexpr(package, filename = NULL, final = TRUE, overview = FALSE, bib = TRUE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{package}{name of a package, a string} \item{filename}{name of a file where to write the generated Rd content, a string. The default should be sufficient in most cases.} \item{final}{logical; if \code{TRUE} the content should be usable without manual editing.} \item{overview}{logical; if \code{TRUE} creates sections with hints what to put in them, otherwise such sections are written to the file but are commented out.} \item{bib}{If TRUE, create a comment line in the references section that will cause \code{\link{rebib}} to import all references from the default bib file. } } \details{ The generated skeleton is functionally (almost) equivalent to that produced by \code{promptPackage}. The difference is that while \code{promptPackage} computes some information and inserts it verbatim in the skeleton, \code{promptPackageSexpr} inserts Sexpr's for the computation of the same information at package build time. In this way there is no need to manually update information like the version of the package. The index of functions (which contains their descriptions) does not need manual updating, as well. \code{promptPackageSexpr} needs to be called only once to create the initial skeleton. Then the Rd file can be edited as needed. If the Rd file is generated with the option \code{bib = TRUE} (or the appropriate lines are added to the refernces section manually) the references can be updated at any time by a call of \code{rebib}. todo: At the moment \code{final=FALSE} has the effect described for \code{overview}. At the time of writing this (2011-11-18) I do not remember if this is intentional or the corresponding `if' clause contains \code{|} by mistake. } \value{ the name of the file (invisibly) } \author{Georgi N. Boshnakov} \note{ The automatically generated information is that of the installed (or at least built) package. Usually this is not a problem (and this is the idea of the function) but it means that if a developer is adding documentation for previously undocumented functions, they will appear in the 'Index' section only after the package is installed again. Similarly, if the description file of the package is changed, the package needs to be installed again for the changes to appear in the overview. Since the documentation is installed together with the package this is no surprise, of course. This may only cause a problem if documentation is produced with \code{R CMD Rd2pdf} before the updated version is installed. This function is not called \code{repromptXXX} since the idea is that it is called only once and then the Rd file can be edited freely, see also `Details'. } %% ~Make other sections like Warning with \section{Warning }{....} ~ % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{Rd} Rdpack/man/Rd_combo.Rd0000644000175000017500000000261414065042214014377 0ustar nileshnilesh\name{Rd_combo} \alias{Rd_combo} %- Also NEED an '\alias' for EACH other topic documented here. \title{Manipulate a number of Rd files} \description{Manipulate a number of Rd files.} \usage{ Rd_combo(rd, f, ..., .MORE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rd}{names of Rd files, a character vector.} \item{f}{function to apply, see Details.} \item{\dots}{further arguments to pass on to \code{f}.} \item{.MORE}{another function to be applied for each file to the result of \code{f}.} } \details{ \code{Rd_combo} parses each file in \code{rd}, applies \code{f} to the Rd object, and applies the function \code{.MORE} (if supplied) on the results of \code{f}. A typical value for \code{.MORE} is \code{reprompt} or another function that saves the resulting Rd object. todo: \code{Rd_combo} is already useful but needs further work. } %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ \dontrun{ rdnames <- dir(path = "./man", pattern=".*[.]Rd$", full.names=TRUE) ## which Rd files don't have a value section? counts <- unlist(Rd_combo(rdnames, function(x) length(Rdo_locate_core_section(x, "\\value")))) rdnames[counts == 0] ## reprompt all files Rd_combo(rdnames, reprompt) for(nam in rdnames) try(reprompt(nam)) for(nam in rdnames) try(reprompt(nam, sec_copy=FALSE)) } } \keyword{Rd} %\keyword{Rdprocessing} Rdpack/man/Rdo_set_section.Rd0000644000175000017500000000405113501141722015771 0ustar nileshnilesh\name{Rdo_set_section} \alias{Rdo_set_section} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Replace a section in an Rd file } \description{ Replace a section in an Rd file. } \usage{ Rdo_set_section(text, sec, file, \dots) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{text}{the new text of the section, a character vector.} \item{sec}{name of the section.} \item{file}{name of the file.} \item{...}{arguments to be passed on to \code{Rdo_modify}.} } \details{ Parses the file, replaces the specified section with the new content and writes the file back. The text is processed as appropriate for the particular section (\code{sec}). For example: \code{Rdo_set_section("Georgi N. Boshnakov", "author", "./man/Rdo2Rdf.Rd")} (Some care is needed with the author field for "xxx-package.Rd" files, such as "Rdpack-package.Rd", where the \verb{Author(s)} field has somewhat different layout.) By default \code{Rdo_set_section} does not create the section if it does not exist, since this may not be desirable for some Rd files. The "..." arguments can be used to change this, they are passed on to \code{\link{Rdo_modify}}, see its documentation for details. } \value{ This function is used mainly for the side effect of changing \code{file}. It returns the Rd formatted text as a character vector. } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{Rdo_modify}} } \examples{ fnA <- tempfile("dummyfun", fileext = "Rd") dummyfun <- function(x) x reprompt(dummyfun, filename = fnA) Rdo_show(tools::parse_Rd(fnA)) ## set the author section, create it if necessary. Rdo_set_section("A.A. Author", "author", fnA, create = TRUE) Rdo_show(tools::parse_Rd(fnA)) ## replace the author section Rdo_set_section("Georgi N. Boshnakov", "author", fnA) Rdo_show(tools::parse_Rd(fnA)) unlink(fnA) } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoBuild} Rdpack/man/update_aliases_tmp.Rd0000644000175000017500000000135513501141722016515 0ustar nileshnilesh\name{update_aliases_tmp} \alias{update_aliases_tmp} %- Also NEED an '\alias' for EACH other topic documented here. \title{Update aliases for methods in Rd objects} \description{Update aliases for methods in Rd objects} \usage{ update_aliases_tmp(rdo, package = NULL) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object} \item{package}{the name of a package, a character string.} } \details{ This is a quick fix. todo: complete it! } \value{ the updated Rd object } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoS4} Rdpack/man/makeVignetteReference.Rd0000644000175000017500000001030613611571464017124 0ustar nileshnilesh\name{makeVignetteReference} \alias{makeVignetteReference} \alias{vigbib} \title{Make bibtex references for vignettes} \description{Make bibtex references for vignettes} \usage{ makeVignetteReference(package, vig = 1, verbose = TRUE, title, author, type = "pdf", bibtype = "Article", key = NULL) vigbib(package, verbose = TRUE, \dots, vig = NULL) } \arguments{ \item{package}{ a character string, the name of an installed package. } \item{vig}{ an integer number or a character string identifying a vignette. } \item{verbose}{ if \code{TRUE}, print the references in Bibtex format. } \item{title}{a character string, title of the vignette, see Details.} \item{author}{a character string, title of the vignette, see Details.} \item{type}{a character string, type of the vignette, such as \code{"pdf"} or \code{"html"}. Currently ignored. } \item{bibtype}{a character string, Bibtex type for the reference, defaults to \code{"Article"}. } \item{key}{a character string specifying a key for the Bibtex entry. If missing, suitable key is generated automatically. } \item{...}{ arguments passed by \code{vigbib()} to \code{makeVignetteReference()}. } } \details{ \code{vigbib()} generates Bibtex references for all vignettes in a package. \code{makeVignetteReference()} produces a Bibtex entry for a particular vignette. There seems to be no standard way to cite vignettes in R packages. For vignettes that are complete journal papers (most notably in the Journal of Statistical Software), the authors would usually prefer the papers to be cited, rather than the vignette. In any case, consulting the output of \code{citation("a_package")} is the best starting point. If the vignette has been extended substantially after the paper was published, cite both. In many cases it is sufficient to give the command that opens the vignette, e.g.: \code{vignette("Inserting_bibtex_references", package = "Rdpack")}. \code{makeVignetteReference()} makes a Bibtex entry for one vignette. It looks for the available vignettes using \code{vignette(package=package)}. Argument \code{vig} can be a character string identifying the vignette by the name that would be used in a call to \code{vignette()}. It can also be an integer, identifying the vignette by the index (in the order in which the vignettes are returned by \code{vignette()}). By default the first vignette is returned. If \code{vig} is not suitable, a suitable list of alternatives is printed. For \code{vigbib()} it is sufficient to give the name of a package. It accepts all arguments of \code{makeVignetteReference()} except \code{vig} (actually, supplying \code{vig} is equivallent to calling \code{makeVignetteReference()} directly). The remaining arguments can be used to overwrite some automatically generated entries. For example, the vignette authors may not be the same as the package authors. } \value{ a bibentry object containing the generated references (the Bibtex entries are also printed, so that they can be copied to a bib file) } %\references{ %%% ~put references to the literature/web site here ~ %} \author{Georgi N. Boshnakov} %\note{ %%% ~~further notes~~ %} %% ~Make other sections like Warning with \section{Warning }{....} ~ %\seealso{ %%% ~~objects to See Also as \code{\link{help}}, ~~~ %} \examples{ ## NOTE (2020-01-21): the following examples work fine, but are not ## rendered correctly by pkgdown::build_site(), so there may be errors ## on the site produced by it, https://geobosh.github.io/Rdpack/. vigbib("Rdpack") makeVignetteReference("Rdpack", vig = 1) makeVignetteReference("Rdpack", vig = "Inserting_bibtex_references") ## the first few characters of the name suffice: makeVignetteReference("Rdpack", vig = "Inserting_bib") ## this gives an error but also prints the available vignettes: ## makeVignetteReference("Matrix", vig = "NoSuchVignette") vigbib("utils") makeVignetteReference("utils", vig = 1) ## commented out since can be slow: ## high <- installed.packages(priority = "high") ## highbib <- lapply(rownames(high), function(x) try(Rdpack:::vigbib(x, verbose = FALSE))) } \keyword{bibtex} % use one of RShowDoc("KEYWORDS") Rdpack/man/get_bibentries.Rd0000644000175000017500000001106113734376022015645 0ustar nileshnilesh\name{get_bibentries} \alias{get_bibentries} %- Also NEED an '\alias' for EACH other topic documented here. \title{Get all references from a Bibtex file} \description{Get all references from a Bibtex file.} \usage{ get_bibentries(\dots, package = NULL, bibfile = "REFERENCES.bib", url_only = FALSE, stop_on_error = TRUE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{\dots}{arguments to be passed on to the file getting functions, character strings, see `Details'.} \item{package}{name of a package, a character string or NULL.} \item{bibfile}{name of a Bibtex file, a character string.} \item{url_only}{ if TRUE, restrict percent escaping to BibTeX field \code{"URL"}.} \item{stop_on_error}{ if \code{TRUE} stop on error, otherwise issue a warning and return an empty \code{bibentryRd} object. } } \details{ \code{get_bibentries} parses the specified file. % using \code{read.bib} from package \pkg{bibtex} % \insertCite{Rpack:bibtex}{Rdpack} and sets its \code{names} attribute to the keys of the bib elements (\code{read.bib()} does this since version version 0.4.0 of \pkg{bibtex}, as well). Here is what \code{get_bibentries} does on top of \code{read.bib} (the details are further below): \itemize{ \item \code{get_bibentries} deals with percent signs in URL's. \item if the current working directory is in the development directory of \code{package}, \code{get_bibentries} will first search for the bib file under that directory. } \code{bibfile} should normally be the base name of the Bibtex file. Calling \code{get_bibentries} without any \code{"\dots"} arguments results in looking for the Bibtex file in the current directory if package is NULL or missing, and in the installation directory of the specified package, otherwise. Argument "\dots" may be used to specify directories. If \code{package} is missing or NULL, the complete path is obtained with \code{file.path(..., bibfile)}. Otherwise \code{package} must be a package name and the file is taken from the installation directory of the package. Again, argument "\dots" can specify subdirectory as in \code{system.file}. If the current working directory is in the development directory of \code{package}, the bib file is first sought there before resorting to the installation directory. Although the base \R packages do not have files REFERENCES.bib, argument \code{package} can be set to one of them, e.g. \code{"base"}. This works since package \pkg{bibtex} provides bib files for the core packages. By default, \code{get_bibentries} escapes unescaped percent signs in all fields of bibtex objects. To restrict this only to field "url", set argument \code{url_only} to \code{FALSE}. \code{get_bibentries} returns an object from class \code{"bibentryRd"}, which inherits from bibentry. The printing method for \code{"bibentryRd"} unescapes percent signs in URLs for some styles where the escapes are undesirable. } \value{ a bibentryRd object inheriting from bibentry } \references{ \insertAllCited{} } \author{Georgi N. Boshnakov} % \note{ % %% ~~further notes~~ % } % % %% ~Make other sections like Warning with \section{Warning }{....} ~ % % \seealso{ % %% ~~objects to See Also as \code{\link{help}}, ~~~ % } \examples{ r <- get_bibentries(package = "Rdpack") r print(r, style = "html") ## Bib from base R packages are disabled in Rdpack v2 (notify the ## maintainer of Rdpack or raise an issue on github if you wish this back). ## ## b <- get_bibentries(package = "stats") ## print(b[[1]], style = "R") ## print(b[[1]], style = "citation") ## here the url field contains percent encoding fn_url <- system.file("examples", "url_with_percents.bib", package = "Rdpack") u <- get_bibentries(bibfile = fn_url) ## the links produced by all of the following are valid ## and can be put in a browser print(u, style = "html") print(u, style = "bibtex") print(u, style = "R") print(u, style = "text") print(u, style = "citation") ## The link here contains escapes but when put in a LaTeX document ## which uses the JSS style it generates correct clickable link, ## (see Details section) print(u, style = "latex") ## here the journal field contains percent encoding fn_other <- system.file("examples", "journal_with_percents.bib", package = "Rdpack") j <- get_bibentries(bibfile = fn_url) print(j, style = "html") print(j, style = "bibtex") print(j, style = "R") print(j, style = "text") print(j, style = "citation") print(j, style = "latex") } \keyword{ bibtex } \keyword{programming} Rdpack/man/Rdo_piecetag.Rd0000644000175000017500000000254513501141722015241 0ustar nileshnilesh\name{Rdo_piecetag} \alias{Rdo_piecetag} \alias{Rdo_sectype} \alias{is_Rdsecname} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Give information about Rd elements } \description{ Give information about Rd elements. } \usage{ Rdo_piecetag(name) Rdo_sectype(x) is_Rdsecname(name) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{name}{the name of an Rd macro, a string.} \item{x}{the name of an Rd macro, a string.} } \details{ \code{Rdo_piecetag} gives the "Rd_tag" of the Rd macro \code{name}. \code{Rdo_sectype} gives the "Rd_tag" of the Rd section \code{x}. \code{is_Rdsecname(name)} returns TRUE if \code{name} is the name of a top level Rd section. The information returned by these functions is obtained from the charater vectors \code{Rdo_piece_types} and \code{Rdo_predefined_sections}. } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{Rdo_piece_types}} and \code{\link{Rdo_predefined_sections}} } \examples{ Rdo_piecetag("eqn") # ==> "VERB" Rdo_piecetag("code") # ==> "RCODE" Rdo_sectype("usage") # ==> "RCODE" Rdo_sectype("title") # ==> "TEXT" Rdo_sectype("arguments") } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoProgramming} Rdpack/man/parse_Rdpiece.Rd0000644000175000017500000000530614013547466015435 0ustar nileshnilesh\name{parse_Rdpiece} \alias{parse_Rdpiece} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Parse a piece of Rd source text } \description{ Parse a piece of Rd source text. } \usage{ parse_Rdpiece(x, result = "") } %- maybe also 'usage' for other objects documented here. \arguments{ \item{x}{the piece of Rd text, a character vector.} \item{result}{if "text", converts the result to printable text (e.g. to be shown to the user), otherwise returns an Rd object.} } \details{ \code{parse_Rdpiece} parses a piece of source Rd text. The text may be an almost arbitrary piece that may be inserted in an Rd source file, except that it should not be a top level section (use \code{\link{parse_Rdtext}} for sections). Todo: it probably can be also a parsed piece, check! This is somewhat tricky since \code{parse_Rd} does not accept arbitrary piece of Rd text. It handles either a complete Rd source or a fragment, defined (as I understand it) as a top level section. To circumvent this limitation, this function constructs a minimal complete Rd source putting argument \code{x} in a section (currently "Note") which does not have special formatting on its own. After parsing, it extracts only the part corresponding to \code{x}. \code{parse_Rdpiece} by default returns the parsed Rd piece. However, if \code{result="text"}, then the text is formatted as the help system would do when presenting help pages in text format. \strong{TODO:} add an argument for macros? } \value{ a parsed Rd piece or its textual representation as described in Details } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ # the following creates Rd object rdo dummyfun <- function(x) x u1 <- list_Rd(name = "Dummyname", alias = "dummyfun", title = "Dummy title", description = "Dummy description", usage = "dummyfun(x,y)", value = "numeric vector", author = "A. Author", Rd_class = TRUE ) fn <- tempfile("dummyfun", fileext = "Rd") reprompt(dummyfun, filename = fn) rdo <- tools::parse_Rd(fn) # let's prepare a new item rd <- "\\\\item{...}{further arguments to be passed on.}" newarg <- parse_Rdtext(rd, section = "\\\\arguments") # now append 'newarg' to the arguments section of rdo iarg <- which(tools:::RdTags(rdo) == "\\\\arguments") rdoa <- append_to_Rd_list(rdo, newarg, iarg) Rdo_show(rdoa) # for arguments and other frequent tasks, there are specialised functions dots <- paste0("\\\\", "dots") rdob <- Rdo_append_argument(rdo, dots, "further arguments to be passed on.") Rdo_show(reprompt(rdob, filename = fn)) unlink(fn) } \keyword{RdoProgramming} Rdpack/man/Rdo_show.Rd0000644000175000017500000000170513611566707014455 0ustar nileshnilesh\name{Rdo_show} \alias{Rdo_show} \title{Convert an Rd object to text and show it} \description{Render an Rd object as text and show it.} \usage{ Rdo_show(rdo) } \arguments{ \item{rdo}{an Rd object} } \details{ \code{Rdo_show} renders the help page represented by \code{rdo} as text and shows it with \code{file.show()}. \code{Rdo_show} is a simplified front end to \code{utils::Rd2txt}. See \code{\link{viewRd}} for more complete rendering, including of references and citations. } \value{ Invisible \code{NULL}. The function is used for the side effect of showing the text representation of \code{rdo}. } \author{Georgi N. Boshnakov} \seealso{ \code{\link{viewRd}} } \examples{ ## create a minimal Rd object u1 <- list_Rd(name = "Dummyname", alias = "Dummyallias1", title = "Dummy title", description = "Dummy description", Rd_class = TRUE ) \dontrun{ ## run this interactively: Rdo_show(u1) } } \keyword{Rd} Rdpack/man/zzcapture_promptany.Rd0000644000175000017500000000510213501141722017004 0ustar nileshnilesh\name{.capture_promptAny} \alias{.capture_promptAny} \alias{.capture_installed_help} %- Also NEED an '\alias' for EACH other topic documented here. \title{Internal functions used by reprompt} \description{Internal functions used by reprompt.} \usage{ .capture_promptAny(fnam, type, package, final, \dots, methods) .capture_installed_help(fnam, type = NULL, package = NULL, suffix = NULL) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{fnam}{extended name of the object, such as "fun", "gen-methods", "S4cl-class" or "pkname-package", see details.} \item{final}{if TRUE, put dummy title and description to make the file immediately usable.} \item{\dots}{further arguments to pass on to the prompt function(s).} \item{methods}{methods to consider, used only when describing S4 methods.} \item{type}{type of documentation, such as "methods" and "class", see Details.} \item{package}{the package where to look for objects or documentation, useful if more objects of the same name exist.} \item{suffix}{a character string to be appended to \code{fnam} to obtain the complete name of the help topic, e.g. "-class", "-method". } } \details{ These functions are used internally by \code{reprompt}. It falls back to them when only when the user has not supplied an Rd file in the call. Note that for editing it is preferable to use the source Rd files (when available), since some hard coded information in the installed help may have been produced by more elaborated code in the Rd sources, most notably Sweave expressions. \code{.capture_promptAny} is used to generate documentation when none has been supplied by the user or loaded in the session. \code{.capture_promptAny} parses \code{fnam} to obtain the name of the object and the type of the required documentation (function, methods, class), then generates it. Currently this is done with the built in functions of the \code{promptXXX} family. \code{.capture_installed_help} does exactly that --- it captures the currently installed requested help topic. This function needs clean up. It was originally written at a time when both the old and new help formats where co-existing. } \value{ an Rd object on success or a \code{try-error} object otherwise } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ ##---- Should be DIRECTLY executable !! ---- } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{internal} Rdpack/man/inspect_Rd.Rd0000644000175000017500000000510113501141722014735 0ustar nileshnilesh\name{inspect_Rd} \alias{inspect_Rd} \alias{inspect_Rdfun} \alias{inspect_Rdmethods} \alias{inspect_Rdclass} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Inspect and update an Rd object or file } \description{ Inspect and update an Rd object or file. } \usage{ inspect_Rd(rdo, package = NULL) inspect_Rdfun(rdo, alias_update = TRUE) inspect_Rdmethods(rdo, package = NULL) inspect_Rdclass(rdo) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object or file name} \item{package}{name of a package} \item{alias_update}{if \code{TRUE}, add missing alias entries for functions with usage statements.} } \details{ These functions check if the descriptions of the objects in \code{rdo} are consistent with their current definitions and update them, if necessary. The details depend on the type of the documented topic. In general, the functions update entries that can be produced programmatically, possibly accompanied with a suggestion to the author to write some additional text. \code{inspect_Rd} checks the \verb{\name} section of \code{rdo} and dispatches to one of the other \code{inspect_XXX} functions depening on the type of the topic. \code{inspect_Rdfun} processes documentation of functions. It checks the usage entries of all functions documented in \code{rdo} and updates them if necessary. It appends "\verb{\alias}" entries for functions that do not have them. Entries are created for any arguments that are missing from the "\verb{\arguments}" section. Warning is given for arguments in the "\verb{\arguments}" section that are not present in at least one usage entry. \code{inspect_Rdfun} understands the syntax for S3 methods and S4 methods used in "usage" sections, as well. The S4 methods may also be in a section as produced by \code{promptMethods}. \code{inspect_Rdmethods} checks and updates documentation of an S4 generic function. \code{inspect_Rdclass} checks and updates documentation of an S4 class. Since method signatures and descriptions may be present in documentation of a class, as well as in that of methods, the question arises where to put "\verb{\alias}" entries to avoid duplication. Currently, alias entries are put in method descriptions. } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ % \examples{ % ##---- Should be DIRECTLY executable !! ---- % } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoProgramming} Rdpack/man/Rdo_empty_sections.Rd0000644000175000017500000000306113501141722016517 0ustar nileshnilesh\name{Rdo_empty_sections} \alias{Rdo_empty_sections} \alias{Rdo_drop_empty} %- Also NEED an '\alias' for EACH other topic documented here. \title{Find or remove empty sections in Rd objects} \description{Find or remove empty sections in Rd objects} \usage{ Rdo_empty_sections(rdo, with_bs = FALSE) Rdo_drop_empty(rdo, sec = TRUE) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object or Rd source text.} \item{with_bs}{if \code{TRUE} return the section names with the leading backslash.} \item{sec}{not used} } \details{ The function \code{checkRd} is used to determine which sections are empty. } \value{ For \code{Rdo_empty_sections}, the names of the empty sections as a character vector. For \code{Rdo_drop_empty}, the Rd object stripped from empty sections. } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ dummyfun <- function(x) x rdo8 <- list_Rd(name = "Dummyname", alias = "dummyfun", title = "Dummy title", description = "Dummy description", usage = "dummyfun(x,y)", value = "numeric vector", author = "", details = "", note = "", Rd_class=TRUE ) Rdo_empty_sections(rdo8) # "details" "note" "author" rdo8a <- Rdo_drop_empty(rdo8) Rdo_empty_sections(rdo8a) # character(0) } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{Rdprocessing} \keyword{RdoBuild} Rdpack/man/Rdreplace_section.Rd0000644000175000017500000000366113501141722016301 0ustar nileshnilesh\name{Rdreplace_section} \alias{Rdreplace_section} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Replace the contents of a section in one or more Rd files} \description{Replace the contents of a section in one or more Rd files.} \usage{ Rdreplace_section(text, sec, pattern, path = "./man", exclude = NULL, ...) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{text}{the replacement text, a character string.} \item{sec}{the name of the section without the leading backslash, as for \code{Rdo_set_section}.} \item{pattern}{regular expression for R files to process, see Details.} \item{path}{the directory were to look for the Rd files.} \item{exclude}{regular expression for R files to exclude, see Details.} \item{\dots}{not used.} } \details{ \code{Rdreplace_section} looks in the directory specified by \code{path} for files whose names match \code{pat} and drops those whose names match \code{exclude}. Then it replaces section \code{sec} in the files selected in this way. \code{Rdreplace_section} is a convenience function to replace a section (such as a keyword or author) in several files in one go. It calls \code{\link{Rdo_set_section}} to do the work. } \value{ A vector giving the full names of the processed Rd files, but the function is used for the side effect of modifying them as described in section Details. } % \references{ % %% ~put references to the literature/web site here ~ % } \author{ Georgi N. Boshnakov } % \note{ % %% ~~further notes~~ % } % %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{Rdo_set_section}} } \examples{ \dontrun{ # replace the author in all Rd files except pkgname-package Rdreplace_section("A. Author", "author", ".*[.]Rd$", exclude = "-package[.]Rd$") } } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{RdoBuild} Rdpack/man/Rdo_is_newline.Rd0000644000175000017500000000171213501141722015607 0ustar nileshnilesh\name{Rdo_is_newline} \alias{Rdo_is_newline} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Check if an Rd fragment represents a newline character } \description{ Check if an Rd fragment represents a newline character } \usage{ Rdo_is_newline(rdo) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object} } \details{ This is a utility function that may be used to tidy up Rd objects. It returns TRUE if the Rd object represents a newline character, i.e. it is a character vector of length one containing the string \verb{"\n"}. Attributes are ignored. Otherwise it returns FALSE. } \value{ TRUE or FALSE } \author{Georgi N. Boshnakov} %% ~Make other sections like Warning with \section{Warning }{....} ~ % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{RdoProgramming} %\keyword{RdoElements} \keyword{RdoBuild} Rdpack/man/get_usage_text.Rd0000644000175000017500000000274213501141722015662 0ustar nileshnilesh\name{get_usage_text} \alias{get_usage_text} %- Also NEED an '\alias' for EACH other topic documented here. \title{ Get the text of the usage section of Rd documentation } \description{ Get the text of the usage section of Rd documentation. } \usage{ get_usage_text(rdo) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{rdo}{an Rd object or a character string} } \details{ If \code{rdo} is a string, it is parsed to obtain an Rd object. The content of section "\verb{\usage}" is extracted and converted to string. } \value{ a string } \author{Georgi N. Boshnakov} \note{ todo: \code{get_usage_text} can be generalised to any Rd section but it is better to use a different approach since \code{print.Rd()} does not take care for some details (escaping \%, for example). Also, the functions that use this one assume that it returns \R code, which may not be the case if the usage section contains Rd comments. } %% ~Make other sections like Warning with \section{Warning }{....} ~ \examples{ ## get the Rd object documenting Rdo_macro #h <- utils::help("Rdo_macro", lib.loc = .libPaths()) #rdo <- utils:::.getHelpFile(h) rdo <- Rdo_fetch("Rdo_macro", "Rdpack") # extract the usage section and print it: ut <- get_usage_text(rdo) cat(ut, sep = "\n") } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. %\keyword{RdoProgramming} \keyword{RdoUsage} %\keyword{RdFunction} Rdpack/man/deparse_usage.Rd0000644000175000017500000000574614041230016015464 0ustar nileshnilesh\name{deparse_usage} \alias{deparse_usage} \alias{deparse_usage1} \alias{as.character.f_usage} \title{Convert f_usage objects to text appropriate for usage sections in Rd files \Sexpr[stage=build,results=hide]{require(Rdpack)} } \description{Converts f_usage objects to text appropriate for usage sections in Rd files. Handles S3 methods. } \usage{ deparse_usage(x) deparse_usage1(x, width = 72) \method{as.character}{f_usage}(x, \dots ) } \arguments{ \item{x}{ an object from class \code{"f_usage"}. For \code{deparse_usage}, \code{x} can also be a list of \code{"f_usage"} objects. } \item{width}{maximal width of text on a line.} \item{...}{ignored.} } \details{ Both, \code{deparse_usage1} and the \code{as.character} method for class \code{"f_usage"}, convert an \code{"f_usage"} object to a character string suitable for Rd documentation. The \code{as.character} method is the user level function (it just calls \code{deparse_usage1}), \code{deparse_usage1} is internal function for programming. In the example below the first command creates an \code{"f_usage"} object, then the second converts it to character string. \printExample{(a <- pairlist2f_usage1(formals(cor), "cor"));cat(as.character(a))} Each usage entriy is formatted and, if necessary, split over several lines. The width (number of characters) on a line can be changed with argument \code{width}. \code{deparse_usage} can be used when \code{x} is a list of \code{"f_usage"} objects. It calls \code{deparse_usage1} with each of them and returns a character vector with one element for each component of \code{x}. When \code{x} is an object from class \code{"f_usage"}, \code{deparse_usage} is equivalent to \code{deparse_usage1}. } \value{ For \code{deparse_usage1} and \code{as.character.f_usage}, a named character vector of length one (the name is the function name). For \code{deparse_usage}, a named character vector with one entry for the usage text for each function. } \author{Georgi N. Boshnakov} \seealso{ \code{\link{pairlist2f_usage1}} } \examples{ cur_wd <- getwd() tmpdir <- tempdir() setwd(tmpdir) ## prepare a list of "f_usage" objects fnseq <- reprompt(seq) # get and save the help page of "seq" rdoseq <- tools::parse_Rd(fnseq) # parse the Rd file ut <- get_usage_text(rdoseq) # get the contents of the usage section cat(ut, "\n") # of seq() (a character string) utp <- parse_usage_text(ut) # parse to a list of "f_usage" objects ## deparse the "f_usage" list - each statement gets a separate string cat(deparse_usage(utp), sep = "\n") ## explore some of the usage entries individually; ## the generic seq() has a boring signature utp[[1]] as.character(utp[[1]]) deparse_usage1(utp[[1]]) # same ## the default S3 method is more interesting utp[[2]] cat(deparse_usage1(utp[[2]])) cat(as.character(utp[[2]])) # same unlink(fnseq) setwd(cur_wd) unlink(tmpdir) } %\keyword{RdoProgramming} \keyword{RdoUsage} %\keyword{RdFunction} Rdpack/vignettes/0000755000175000017500000000000014203665045013625 5ustar nileshnileshRdpack/vignettes/Inserting_figures_and_evaluated_examples.org0000644000175000017500000001706613501141722024577 0ustar nileshnilesh#+PROPERTY: header-args:R :cache yes :session ravel01-r :results value :exports both #+OPTIONS: toc:nil #+LaTeX_CLASS: Rvignette #+LaTeX_CLASS_OPTIONS: [a4paper,twoside,11pt,nojss,article] #+TITLE: Inserting figures and evaluated examples #+AUTHOR: Georgi N. Boshnakov #+MACRO: keywords examples, graphics, figures, Rd, R #+MACRO: Rpackage Rdpack #+KEYWORDS: examples, graphics, figures, Rd, R #+LATEX_HEADER: % \usepackage{Sweave} #+LATEX_HEADER: \author{Georgi N. Boshnakov} #+LATEX_HEADER: \Plainauthor{Georgi N. Boshnakov} #+LATEX_HEADER: \Address{ #+LATEX_HEADER: Georgi N. Boshnakov\\ #+LATEX_HEADER: School of Mathematics\\ #+LATEX_HEADER: The University of Manchester\\ #+LATEX_HEADER: Oxford Road, Manchester M13 9PL, UK\\ #+LATEX_HEADER: URL: \url{http://www.maths.manchester.ac.uk/~gb/} #+LATEX_HEADER: } #+LATEX_HEADER: <>= #+LATEX_HEADER: library(Rdpack) #+LATEX_HEADER: pd <- packageDescription("Rdpack") #+LATEX_HEADER: @ #+LATEX_HEADER: \Abstract{ #+LATEX_HEADER: This vignette discusses Rd macros provided by package \pkg{Rdpack} for #+LATEX_HEADER: inserting evaluated examples and programmatically created figures. These #+LATEX_HEADER: macros are convenience wrappers around the native capabilities provided #+LATEX_HEADER: by the Rd parser. The macros work in Rd files and roxygen2 comments. #+LATEX_HEADER: \par #+LATEX_HEADER: This vignette is part of package Rdpack, version~\Sexpr{pd$Version}. #+LATEX_HEADER: } #+LATEX_HEADER: #+LATEX_HEADER: \Keywords{examples, graphics, figures, Rd, R} #+LATEX_HEADER: \Plainkeywords{examples, graphics, figures, Rd, R} @@latex:%@@\SweaveOpts{engine=R,eps=FALSE} @@latex:%@@\VignetteIndexEntry{{{{title}}}} @@latex:%@@\VignetteDepends{{{{Rpackage}}}} @@latex:%@@\VignetteKeywords{{{{keywords}}}} @@latex:%@@\VignettePackage{{{{Rpackage}}}} #+BEGIN_SRC R :results value silent :exports none library(Rdpack) pd <- packageDescription("Rdpack") #+END_SRC * Evaluated examples Sometimes the documentation of an object becomes more clear if accompanied by snippets of R code and their results. The standard Rd macro ~\Sexpr~ caters for a number of possibilities to evaluate R code and insert the results and the code in the documentation. The Rd macro ~\printExample~ provided by package ="Rdpack"= builds on it to print a snippet of R code and the results of its evaluation. For example, #+BEGIN_EXAMPLE \printExample{2+2; a <- 2*3; a} #+END_EXAMPLE gives #+BEGIN_EXAMPLE 2 + 2 ##: 4 a <- 2 * 3 a ##: 6 #+END_EXAMPLE Note that each command is printed on a separate line even though in this example the source code is on a single line, separated by semicolons[fn:1]. Similarly to =knitr=, the results are prefixed with comment symbols but the code is not prefixed with anything. The help page of ~?Rdpack::promptUsage~ contains a number of examples created with ~\printExample~. The corresponding Rd file can be obtained from the package tarball or from https://github.com/GeoBosh/Rdpack/blob/master/man/promptUsage.Rd. [fn:1] The argument of ~\printExample~ needed to be on a single line with versions of R before =R-3.6.0=, since the lines after the first were silently ignored, with no errors and no warnings. This should not be a concern if your package requires ~R >= 3.6.0~ anyway or if you can live with somewhat inferior documentation in older versions or =R=. # The argument of ~\printExample~ must be on a single line with released versions of R. # This limitation has been lifted in =R-devel= starting from June 2018 and in =R-3.6.0=. # # From NEWS in R 3.6.0: User macros in Rd files now accept empty and multi-line arguments * Section examples with results The macro ~\printExample~ can be used as many times as needed and is typically placed in section /Details/ of an object's documentation. In contrast, the macro ~\runExamples~ can be used as a replacement of the whole ~\examples~ section in the Rd file. The code and its results are printed just as by ~\printExample~. For example, if the following code is put at the top level in an Rd file (i.e. not in a section): #+BEGIN_EXAMPLE \runExamples{2+2; a <- 2*3; a} #+END_EXAMPLE then it will be evaluated and replaced by a normal section examples: #+BEGIN_EXAMPLE \examples{ 2 + 2 ##: 4 a <- 2 * 3 a ##: 6 } #+END_EXAMPLE This generated examples section is processed by the standard R tools (almost) as if it was there from the outset. In particular, the examples are run by the R's quality control tools and tangled along with examples in other documentation files[fn:2]. A small example package using this feature is at [[https://github.com/GeoBosh/reprexes/tree/master/runExamplesCheck][runExamplesCheck]]. [fn:2] In versions of R before 3.6.0, ~R CMD check~ used to give warnings about unknown ~\Sexpr~ section at top level. See also the note about multiline argument for ~\printExample~. # (Amendment on 2018-10-11: R-devel does no longer give the warning at least since 2018-10-02 # r75388.) # # According to the specification of the Rd format (see [[https://developer.r-project.org/parseRd.pdf][Murdoch (2010), p. 4]] ~\Sexpr~'s at top # level are legal. I need to check with the CRAN team or R devel if such expressions # produced by user macros are excluded on purpose. * Creating and including graphs Figures can be inserted with the help of the standard Rd markup command ~\figure~. The Rd macro ~\insertFig~ provided by package \pkg{Rdpack} takes a snipped of R code, evaluates it and inserts the plot produced by it (using ~\figure~). ~\insertFig~ takes three arguments: a filename, the package name and the code to evaluate to produce the figure. For example, #+BEGIN_EXAMPLE \insertFig{cars.png}{mypackage}{x <- cars$speed; y <- cars$dist; plot(x,y)} #+END_EXAMPLE will evaluate the code[fn:3], save the graph in file ~"man/figures/cars.png"~ subdirectory of package ~"mypackage"~, and include the figure using ~\figure~. Subdirectory ~"figures"~ is created if it doesn't exist. Currently the graphs are saved in ~"png"~ format only. The sister macro ~\makeFig~ creates the graph in exactly the same way as ~\insertFig~ but does not insert it. This can be done with a separate ~\figure~ command. This can be used if additional options are desired for different output formats, see the description of ~\figure~ in "Writing R extensions". [fn:3] See also the remark about using miltiline code in =\printExample=. For figures this is not a problem at all even in older versions of R, since all preparatory code can be put in a separate =\Sexpr=, and then =\insertFig= can be given only the final command producing the graph. ** A technical note The above description should just work. This note is for users who wonder about technicalities. The R documentation can be built in many ways and as a result the directory ~"man/figures/"~ does not necessarily refer to the developers source package. Indeed, when a package is built, R works on a modified and cleaned-up temporary copy of the source directory, so the figures are created in that copy and then included in the package tarball. Similarly during the package check. On the other hand, ~R CMD Rd2pdf~ and some other tools and R functions work directly on the source tree of the package and they will create the figures there. The net effect is that a package tarball always contains freshly generated up-to-date graphs. Developers who never generate the documentation by other means may not even have the directory ~man/figures~ in the source tree of their package (but it will be present in the package tarball). # To avoid splitting 'Affiliation' on two pages #+BEGIN_EXPORT latex \newpage #+END_EXPORT Rdpack/vignettes/Inserting_bibtex_references.Rnw0000644000175000017500000004201014177561276022025 0ustar nileshnilesh% Created 2022-02-05 Sat 20:49 % Intended LaTeX compiler: pdflatex \documentclass[a4paper,twoside,11pt,nojss,article]{jss} \usepackage[T1]{fontenc} \usepackage[left=2cm,right=2cm,bottom=15mm]{geometry} \usepackage{graphicx,color,alltt} \usepackage[authoryear,round,longnamesfirst]{natbib} \usepackage{hyperref} % \usepackage{Sweave} \author{Georgi N. Boshnakov} \Plainauthor{Georgi N. Boshnakov} \Address{ Georgi N. Boshnakov\\ School of Mathematics\\ The University of Manchester\\ Oxford Road, Manchester M13 9PL, UK\\ URL: \url{http://www.maths.manchester.ac.uk/~gb/} } <>= library(Rdpack) pd <- packageDescription("Rdpack") @ \Abstract{ Package \pkg{Rdpack} provides a straightforward way to insert BibTeX references in the documentation of an R package, using the RdMacros feature introduced in R~3.2.0. It works for `roxygen2' documentation, as well. \par This vignette is part of package Rdpack, version~\Sexpr{pd$Version}. } \Keywords{bibliographic references, Rd, bibtex, citations, \proglang{R}} \Plainkeywords{bibliographic references, Rd, bibtex, citations, R} \author{Georgi N. Boshnakov} \date{\today} \title{Inserting references in Rd and roxygen2 documentation} \hypersetup{ pdfauthor={Georgi N. Boshnakov}, pdftitle={Inserting references in Rd and roxygen2 documentation}, pdfkeywords={bibliographic references, Rd, bibtex, citations, R}, pdfsubject={}, pdfcreator={Emacs 26.3 (Org mode 9.1.9)}, pdflang={English}} \begin{document} \maketitle %\SweaveOpts{engine=R,eps=FALSE} %\VignetteIndexEntry{Inserting references in Rd and roxygen2 documentation} %\VignetteDepends{Rdpack} %\VignetteKeywords{bibliographic references, Rd, bibtex, citations, R} %\VignettePackage{Rdpack} \section{Setup} \label{sec:org985340a} To prepare a package for importing BibTeX references it is necessary to tell the package management tools that package \pkg{Rdpack} and its Rd macros are needed. The references should be put in file \texttt{inst/REFERENCES.bib}. These steps are enumerated below in somewhat more detail for convenince: \begin{enumerate} \item Add the following lines to file `DESCRIPTION': \begin{verbatim} Imports: Rdpack RdMacros: Rdpack \end{verbatim} Make sure the capitalisation of \texttt{RdMacros} is as shown. If the field 'RdMacros' is already present, add `Rdpack' to the list on that line. Similarly for field 'Imports'. \item Add the following line to file `NAMESPACE'\footnote{Any function for package \pkg{Rdpack} will do. This is to avoid getting a warning from 'R CMD check'.}: \begin{verbatim} importFrom(Rdpack,reprompt) \end{verbatim} The equivalent line for `roxygen2' is \begin{verbatim} #' @importFrom Rdpack reprompt \end{verbatim} \item Create file \texttt{REFERENCES.bib} in subdirectory \texttt{inst/} of your package and put the bibtex references in it. \end{enumerate} \section{Inserting references in package documentation} \label{sec:org30fe476} Once the steps outlined in the previous section are done, references can be inserted in the documentation as \texttt{\textbackslash{}insertRef\{key\}\{package\}}, where \texttt{key} is the bibtex key of the reference and \texttt{package} is your package. This works in Rd files and in roxygen documentation chunks. In fact, argument 'package' can be any installed R package\footnote{There is of course the risk that the referenced entry may be removed from the other package. So this is probably only useful for one's own packages. Also, the other package would better be one of the packages mentioned in DESCRIPTION.\}}, not necessarily the current one. This means that you don't need to copy references from other packages to your \texttt{"REFERENCES.bib"} file. This works for packages that have \texttt{"REFERENCES.bib"} in their installation directory and for the default packages. See also the help pages \texttt{?Rdpack::insertRef} and \texttt{?Rdpack::Rdpack-package}. For example, the help page \texttt{?Rdpack::insertRef} contains the following lines in section ``References'' of the Rd file: \begin{verbatim} \insertRef{Rpack:bibtex}{Rdpack} \end{verbatim} The first line above inserts the reference labeled \texttt{Rpack:bibtex} in Rdpack's \texttt{REFERENCES.bib}. The second line inserts the reference labeled \texttt{R} in file \texttt{REFERENCES.bib} in package `bibtex'. A roxygen2 documentation chunk might look like this: \begin{verbatim} #' @references #' \insertRef{Rpack:bibtex}{Rdpack} \end{verbatim} \section{Inserting citations} \label{sec:org9601ff6} From version 0.7 of \pkg{Rdpack}, additional Rd macros are available for citations\footnote{They were introduced in the development version 0.6-1, but 0.7 is the first version with them released on CRAN.}. They can be used in both Rd and roxygen2 documentation. If you are using these, it will be prudent to require at least this version of Rdpack in the ``Imports:'' directive in file DESCRIPTION: \texttt{Rdpack (>= 0.7)}. \subsection{Macros for citations} \label{sec:org9454f29} \label{sec:macros-citations} \texttt{\textbackslash{}insertCite\{key\}\{package\}} cites the key and records it for use by \texttt{\textbackslash{}insertAllCited\{\}}, see below. The style of the citations is author-year. The ''et al'' convention is used when there are more than two authors\footnote{This feature was introduced in Rdpack 0.8-2.}. \code{key} can contain more keys separated by commas. Here are some examples (on the left is the code in the documentation chunk, on the right the rendered citation): \begin{center} \begin{tabular}{ll} Documentation source & rendered\\ \hline \texttt{\textbackslash{}insertCite\{parseRd\}\{Rdpack\}} & (Murdoch 2010)\\ \texttt{\textbackslash{}insertCite\{Rpack:bibtex\}\{Rdpack\}} & (Francois 2014)\\ \texttt{\textbackslash{}insertCite\{parseRd,Rpack:bibtex\}\{Rdpack\}} & (Murdoch 2010; Francois 2014)\\ \end{tabular} \end{center} By default the citations are parenthesised \texttt{\textbackslash{}insertCite\{parseRd\}\{Rdpack\}} produces \Sexpr{ insert_citeOnly("parseRd", "Rdpack") }, as in the examples above. To get textual citations, like \Sexpr{ insert_citeOnly("parseRd;textual", "Rdpack") }, put the string \texttt{;textual} at the end of the key. Here are the examples from the table above, rendered as textual citations: \begin{center} \begin{tabular}{ll} Documentation source & rendered\\ \hline \texttt{\textbackslash{}insertCite\{parseRd;textual\}\{Rdpack\}} & Murdoch (2010)\\ \texttt{\textbackslash{}insertCite\{Rpack:bibtex;textual\}\{Rdpack\}} & Francois (2014)\\ \texttt{\textbackslash{}insertCite\{parseRd,Rpack:bibtex;textual\}\{Rdpack\}} & Murdoch (2010); Francois (2014)\\ \end{tabular} \end{center} The last line in the table demonstrates that this also works with several citations. To mix the citations with other text, such as ``see also'' and ``chapter 3'', write the list of keys as a free text, starting it with the symbol \texttt{@} and prefixing each key with it. The \texttt{@} symbol will not appear in the output. For example, the following code: \begin{verbatim} \insertCite{@see also @parseRd and @Rpack:bibtex}{Rdpack} \insertCite{@see also @parseRd; @Rpack:bibtex}{Rdpack} \insertCite{@see also @parseRd and @Rpack:bibtex;textual}{Rdpack} \end{verbatim} produces: \qquad \begin{tabular}{l} Rendered\\ \hline \Sexpr{insert_citeOnly("@see also @parseRd and @Rpack:bibtex", "Rdpack")}\\ \Sexpr{insert_citeOnly("@see also @parseRd; @Rpack:bibtex", "Rdpack")}\\ \Sexpr{insert_citeOnly("@see also @parseRd and @Rpack:bibtex;textual", "Rdpack")}\\ \end{tabular} The text of the arguments of the macro in this free form should have no markup. For example, if you want to put the phrase \texttt{see also} in italic, enclosing it with \texttt{\textbackslash{}emph\{...\}} (in Rd) or the equivalent \texttt{\_...\_} (in markdown) will not work\footnote{For details see \href{https://github.com/GeoBosh/Rdpack/issues/23}{Github issue \#23} raised by Martin R. Smith.}. For textual citations a workaround is to invoke \texttt{\textbackslash{}insertCite} for each key and type the markup outside the macro arguments. For parenthetical citations the solutions is to ask \texttt{\textbackslash{}insertCite} to omit the parentheses by putting \texttt{;nobrackets} at the end of the argument\footnote{With \pkg{Rdpack} versions greater than 2.1.3.}. The parentheses can then be put manually where needed. For example, \begin{verbatim} (\emph{see also} \insertCite{@@parseRd and @Rpack:bibtex;nobrackets}{Rdpack}) \end{verbatim} produces: (\emph{see also} \Sexpr{insert_citeOnly("@@parseRd and @Rpack:bibtex;nobrackets", "Rdpack")}). \subsubsection{Further macros for citations} \label{sec:orgb8b5f68} The macro \texttt{\textbackslash{}insertNoCite\{key\}\{package\}} records one or more references for \texttt{\textbackslash{}insertAllCited} but does not cite it. Setting \texttt{key} to \texttt{*} will record all references from the specified package. For example, \texttt{\textbackslash{}insertNoCite\{R\}\{bibtex\}} records the reference whose key is \texttt{R}, while \texttt{\textbackslash{}insertNoCite\{*\}\{utils\}} records all references from package ``utils'' for inclusion by \texttt{\textbackslash{}insertAllCited}. \texttt{\textbackslash{}insertCiteOnly\{key\}\{package\}} is as \texttt{\textbackslash{}insertCite} but does not record the key for the list of references assembled by \texttt{\textbackslash{}insertAllCited}. \subsection{Automatically generating lists of references} \label{sec:org9550879} The macro \texttt{\textbackslash{}insertAllCited\{\}} can be used to insert all references cited with \texttt{\textbackslash{}insertCite} or \texttt{\textbackslash{}insertNoCite}. A natural place to put this macro is the references section. The Rd section may look something like: \begin{verbatim} \references{ \insertAllCited{} } \end{verbatim} The analogous documentation chunk in roxygen2 might look like this: \begin{verbatim} #' @references #' \insertAllCited{} \end{verbatim} \subsection{Changing the style of references} \label{sec:org9be8049} Package \texttt{Rdpack} supports bibliography styles for lists of references\footnote{Support for styles is available since \texttt{Rdpack (>= 0.8)}.}. Currently the only alternative offered is to use long names (Georgi N. Boshnakov) in place of the default style (Boshnakov GN). More comprehensive alternatives can be included if needed or requested. To cause all lists of references produced by \texttt{\textbackslash{}insertAllCited} in a package to appear with full names, add \texttt{.onLoad()} function to your package. If you don't have \texttt{.onLoad()}, just copy the following definition: <<>>= .onLoad <- function(lib, pkg){ Rdpack::Rdpack_bibstyles(package = pkg, authors = "LongNames") invisible(NULL) } @ %def If you already have \texttt{.onLoad()}, add the line containing the \texttt{Rdpack::Rdpack\_bibstyles} call to it. After installling/reloading your package the lists of references should appear with long author names. "Rdpack" itself now uses this style. \section{Possible issues} \label{sec:orgbf633c1} \subsection{Warning from 'R CMD build'} \label{sec:org73ebe35} If 'R CMD build' or \texttt{devtools::build()} gives a warning along the lines of: \begin{verbatim} Warning: C:/temp/RtmpqWQqji/.../XXX.Rd:52: unknown macro '\insertRef' \end{verbatim} then check the syntax in file DESCRIPTION --- the most common cause of this is misspelling \texttt{RdMacros:}. Make sure in particular that `M' is uppercase. \subsection{Development using `devtools'} \label{sec:orgf96b5aa} The described procedure works transparently in `roxygen2' chunks and with Hadley Wickham's `devtools'. Packages are built and installed properly with the `devtools' commands and the references are processed as expected. Currently (2017-08-04) if you run help commands \texttt{?xxx} for functions from the package you are working on and their help pages contain references, you may encounter some puzzling warning messages in `developer' mode, something like: \begin{verbatim} 1: In tools::parse_Rd(path) : ~/mypackage/man/abcde.Rd: 67: unknown macro '\insertRef' \end{verbatim} These warnings are again about unknown macros but the reason is completely different: they pop up because ``devtools'' reroutes the help command to process the developer's Rd sources (rather than the documentation in the installed directory) but doesn't tell \texttt{parse\_Rd} where to look for additional macros\footnote{The claims in this sentence can be deduced entirely from the informative message. Indeed, (1)\textasciitilde{}the error is in processing a source Rd file in the development directory of the package, and (2)\textasciitilde{}the call to \texttt{\textbackslash{}parse\_Rd} specifies only the file.}. These warnings are harmless - the help pages are built properly and no warnings appear outside ``developer'' mode, e.g. in a separate R\textasciitilde{}session. You may also consider using the function \texttt{viewRd()}, discussed below, for viewing Rd files. \subsection{Latex markup in BibTeX entries} \label{sec:org7310075} In principle, BibTeX entries may contain arbitrary Latex markup, while the Rd format supports only a subset. As a consequence, some BibTeX entries may need some editing when included in REFERENCES.bib\footnote{Thanks to Michael Dewey for suggesting the discussion of this.}. Only do this for entries that do not render properly or cause errors, since most of the time this should not be necessary. For encoding related issues of REFERENCES.bib see the dedicated subsection below. If mathematics doesn't render properly replace the Latex dollar syntax with Rd's \texttt{\textbackslash{}eqn}, e.g. \texttt{\$x\textasciicircum{}2\$} with \texttt{\textbackslash{}eqn\{x\textasciicircum{}2\}}. This should not be needed for versions of Rdpack 0.8-4 or later. Some Latex macros may have to be removed or replaced with suitable Rd markup. Again, do this only if they cause problems, since some are supported, e.g. \texttt{\textbackslash{}doi}. See also the overview help page, \code{help("Rdpack-package")}, of \pkg{Rdpack}. Among other things, it contains some dummy references which illustrate the above. \subsection{Encoding of file REFERENCES.bib} \label{sec:org9cfdd04} If a package has a declared encoding (in file \texttt{DESCRIPTION}), \texttt{REFERENCES.bib} is read-in with that encoding\footnote{From \texttt{Rdpack (>=0.9-1)} The issue of not handling the encoding was raised by Professor Brian Ripley.}. Otherwise, the encoding of \texttt{REFERENCES.bib} is assumed to be UTF-8 (which includes ASCII as a subset). Note that BibTeX entries downloaded from online databases and similar sources may contain unexpected characters in other encodings, e.g. 'latin1'. In such cases the check tools in R-devel (since about 2018-10-01) may give warnings like: \begin{verbatim} prepare_Rd: input string 1 is invalid in this locale \end{verbatim} To resolve this, convert the file to the declared encoding or UTF-8. Alternatively, replace the offending symbols with their classic \TeX{}/\LaTeX{} equivalents (which are ASCII). Non-ASCII symbols in BibTeX entries obtained from online databases are often in fields like "Abstract", which are normally not included in lists of references and can be deleted from REFERENCES.bib. One way to check for non-ASCII symbols in a file is \texttt{tools::showNonASCIIfile()}. Since \pkg{Rdpack} switched to the bibtex parser in package \pkg{rbibutils}, if the bib file contains Latex escape sequences standing for accented Latin characters, such as \texttt{\textbackslash{}'e} and \texttt{\textbackslash{}"o}, they are imported as is. They are converted to UTF-8 only when the text is rendered for output. If R's checking tools complain about non-ASCII characters add the following encoding declaration to file DESCRIPTION\footnote{Admittedly, this is not ideal since the user should not need to care how things are processed internally but I haven't pinpointed the exact cause for this.}: \begin{verbatim} Encoding: UTF-8 \end{verbatim} Needless to say, make sure that there are really no characters from encodings like 'latin1'. With the previous bibtex parser (before Rdpack version 1.1.0) the conversion was done earlier, which resulted in confusing messages about non-ASCII characters, even when the file REFERENCES.bib was pure ASCII. This should no longer happen. \section{Viewing Rd files} \label{sec:org4a228d2} A function, \code{viewRd}, to view Rd files in the source directory of a package was introduced in version 0.4-23 of \pkg{Rdpack}. A typical user call would look something like: \begin{verbatim} Rdpack::viewRd("./man/filename.Rd") \end{verbatim} By default the requested help page is shown in text format. To open the page in a browser, set argument \code{type} to \code{"html"}: \begin{verbatim} Rdpack::viewRd("./man/filename.Rd", type = "html") \end{verbatim} Users of 'devtools' can use \code{viewRd()} in place of \code{help()} to view Rd sources\footnote{Yes, your real sources are the \texttt{*.R} files but \code{devtools::document()} transfers the roxygen2 documentation chunks to Rd files (and a few others), which are then rendered by \pkg{R} tools.}. \end{document} Rdpack/vignettes/Inserting_bibtex_references.org0000644000175000017500000004670414177561272022060 0ustar nileshnilesh#+PROPERTY: header-args:R :cache yes :session ravel01-r :results value :exports both #+OPTIONS: toc:nil #+LaTeX_CLASS: Rvignette #+LaTeX_CLASS_OPTIONS: [a4paper,twoside,11pt,nojss,article] #+TITLE: Inserting references in Rd and roxygen2 documentation #+AUTHOR: Georgi N. Boshnakov #+MACRO: keywords bibliographic references, Rd, bibtex, citations, R #+MACRO: Rpackage Rdpack #+KEYWORDS: bibliographic references, Rd, bibtex, citations, R #+LATEX_HEADER: % \usepackage{Sweave} #+LATEX_HEADER: \author{Georgi N. Boshnakov} #+LATEX_HEADER: \Plainauthor{Georgi N. Boshnakov} #+LATEX_HEADER: \Address{ #+LATEX_HEADER: Georgi N. Boshnakov\\ #+LATEX_HEADER: School of Mathematics\\ #+LATEX_HEADER: The University of Manchester\\ #+LATEX_HEADER: Oxford Road, Manchester M13 9PL, UK\\ #+LATEX_HEADER: URL: \url{http://www.maths.manchester.ac.uk/~gb/} #+LATEX_HEADER: } #+LATEX_HEADER: <>= #+LATEX_HEADER: library(Rdpack) #+LATEX_HEADER: pd <- packageDescription("Rdpack") #+LATEX_HEADER: @ #+LATEX_HEADER: \Abstract{ #+LATEX_HEADER: Package \pkg{Rdpack} provides a straightforward way to insert BibTeX references in the #+LATEX_HEADER: documentation of an R package, using the RdMacros feature introduced in R~3.2.0. It #+LATEX_HEADER: works for `roxygen2' documentation, as well. #+LATEX_HEADER: \par #+LATEX_HEADER: This vignette is part of package Rdpack, version~\Sexpr{pd$Version}. #+LATEX_HEADER: } #+LATEX_HEADER: #+LATEX_HEADER: \Keywords{bibliographic references, Rd, bibtex, citations, \proglang{R}} #+LATEX_HEADER: \Plainkeywords{bibliographic references, Rd, bibtex, citations, R} @@latex:%@@\SweaveOpts{engine=R,eps=FALSE} @@latex:%@@\VignetteIndexEntry{{{{title}}}} @@latex:%@@\VignetteDepends{{{{Rpackage}}}} @@latex:%@@\VignetteKeywords{{{{keywords}}}} @@latex:%@@\VignettePackage{{{{Rpackage}}}} # DO NOT CHANGE Latex to LaTeX since Org-ravle changes this to \LaTeX{}, a command which # seems to cause problems with this LaTeX style. #+BEGIN_SRC R :results value silent :exports none library(Rdpack) pd <- packageDescription("Rdpack") #+END_SRC * Setup To prepare a package for importing BibTeX references it is necessary to tell the package management tools that package \pkg{Rdpack} and its Rd macros are needed. The references should be put in file =inst/REFERENCES.bib=. These steps are enumerated below in somewhat more detail for convenince: 1. Add the following lines to file `DESCRIPTION': #+BEGIN_EXAMPLE Imports: Rdpack RdMacros: Rdpack #+END_EXAMPLE Make sure the capitalisation of =RdMacros= is as shown. If the field 'RdMacros' is already present, add `Rdpack' to the list on that line. Similarly for field 'Imports'. 2. Add the following line to file `NAMESPACE'[fn:2]: #+BEGIN_EXAMPLE importFrom(Rdpack,reprompt) #+END_EXAMPLE The equivalent line for `roxygen2' is #+BEGIN_EXAMPLE #' @importFrom Rdpack reprompt #+END_EXAMPLE 3. Create file =REFERENCES.bib= in subdirectory =inst/= of your package and put the bibtex references in it. # [fn:1] Currently `R CMD check' doesn't complain if you don't import `Rdpack', # as long as `Rdpack' is installed on the system (yours, CRAN, win-builder, # etc.). However, services like `appveyor' or `travis-ci' do raise # errors. Thanks to Clemens Schmid and Tim Riffe for allerting me about this. [fn:2] Any function for package \pkg{Rdpack} will do. This is to avoid getting a warning from 'R CMD check'. * Inserting references in package documentation Once the steps outlined in the previous section are done, references can be inserted in the documentation as ~\insertRef{key}{package}~, where =key= is the bibtex key of the reference and =package= is your package. This works in Rd files and in roxygen documentation chunks. In fact, argument 'package' can be any installed R package[fn:3], not necessarily the current one. This means that you don't need to copy references from other packages to your ="REFERENCES.bib"= file. This works for packages that have ="REFERENCES.bib"= in their installation directory and for the default packages. See also the help pages ~?Rdpack::insertRef~ and ~?Rdpack::Rdpack-package~. For example, the help page ~?Rdpack::insertRef~ contains the following lines in section ``References'' of the Rd file: #+BEGIN_EXAMPLE \insertRef{Rpack:bibtex}{Rdpack} #+END_EXAMPLE The first line above inserts the reference labeled =Rpack:bibtex= in Rdpack's =REFERENCES.bib=. The second line inserts the reference labeled =R= in file =REFERENCES.bib= in package `bibtex'. A roxygen2 documentation chunk might look like this: #+BEGIN_EXAMPLE #' @references #' \insertRef{Rpack:bibtex}{Rdpack} #+END_EXAMPLE # %\paragraph*{Note:} # % 2017-08-04 commented out, # % The references are processed when the package is built. So, there is \emph{no need} to # % depend/import/suggest package ="Rdpack"=, it only needs to be installed on your machine. [fn:3] There is of course the risk that the referenced entry may be removed from the other package. So this is probably only useful for one's own packages. Also, the other package would better be one of the packages mentioned in DESCRIPTION.} * Inserting citations From version 0.7 of \pkg{Rdpack}, additional Rd macros are available for citations[fn:4]. They can be used in both Rd and roxygen2 documentation. If you are using these, it will be prudent to require at least this version of Rdpack in the ``Imports:'' directive in file DESCRIPTION: ~Rdpack (>= 0.7)~. [fn:4] They were introduced in the development version 0.6-1, but 0.7 is the first version with them released on CRAN. ** Macros for citations \label{sec:macros-citations} ~\insertCite{key}{package}~ cites the key and records it for use by ~\insertAllCited{}~, see below. The style of the citations is author-year. The ''et al'' convention is used when there are more than two authors[fn:etal]. [fn:etal] This feature was introduced in Rdpack 0.8-2. \code{key} can contain more keys separated by commas. Here are some examples (on the left is the code in the documentation chunk, on the right the rendered citation): # \begin{center} # \begin{tabular}{l|l} # Documentation source & rendered \\ \hline # =\insertCite{parseRd}{Rdpack}= & # \Sexpr{insert_citeOnly("parseRd", "Rdpack")} \\ # =\insertCite{Rpack:bibtex}{Rdpack}= & # \Sexpr{insert_citeOnly("Rpack:bibtex", "Rdpack")} \\ # =\insertCite{parseRd,Rpack:bibtex}{Rdpack}= & # \Sexpr{insert_citeOnly("parseRd,Rpack:bibtex", "Rdpack")} # \end{tabular} # \end{center} # # By default the citations are parenthesised =\insertCite{parseRd}{Rdpack}= produces # \Sexpr{insert_citeOnly("parseRd", "Rdpack")}, as in the examples above. To get textual # citations, like \Sexpr{insert_citeOnly("parseRd;textual", "Rdpack")} put the string # \code{;textual} at the end of the key. Here are the examples from the table above, rendered # as textual citations: # \begin{center} # \begin{tabular}{l|l} # Documentation source & rendered \\ \hline # =\insertCite{parseRd;textual}{Rdpack}= & # \Sexpr{insert_citeOnly("parseRd;textual", "Rdpack")} \\ # =\insertCite{Rpack:bibtex;textual}{Rdpack}= & # \Sexpr{insert_citeOnly("Rpack:bibtex;textual", "Rdpack")} \\ # =\insertCite{parseRd,Rpack:bibtex;textual}{Rdpack}= & # \Sexpr{insert_citeOnly("parseRd,Rpack:bibtex;textual", "Rdpack")} # \end{tabular} # \end{center} #+name: R-inscite #+BEGIN_SRC R :var x="", textual=0 :results value silent :exports none insert_citeOnly(if(textual == 0) x else paste0(x, ";textual"), "Rdpack") #+END_SRC | Documentation source | rendered | |---------------------------------------------+-------------------------------| | ~\insertCite{parseRd}{Rdpack}~ | (Murdoch 2010) | | ~\insertCite{Rpack:bibtex}{Rdpack}~ | (Francois 2014) | | ~\insertCite{parseRd,Rpack:bibtex}{Rdpack}~ | (Murdoch 2010; Francois 2014) | #+TBLFM: @2$2='(org-sbe "R-inscite" (x "\"parseRd\""))::@3$2='(org-sbe "R-inscite" (x "\"Rpack:bibtex\""))::@4$2='(org-sbe "R-inscite" (x "\"parseRd,Rpack:bibtex\"")) By default the citations are parenthesised =\insertCite{parseRd}{Rdpack}= produces src_R{insert_citeOnly("parseRd", "Rdpack")}, as in the examples above. To get textual citations, like src_R{insert_citeOnly("parseRd;textual", "Rdpack")}, put the string =;textual= at the end of the key. Here are the examples from the table above, rendered as textual citations: | Documentation source | rendered | |-----------------------------------------------------+---------------------------------| | ~\insertCite{parseRd;textual}{Rdpack}~ | Murdoch (2010) | | ~\insertCite{Rpack:bibtex;textual}{Rdpack}~ | Francois (2014) | | ~\insertCite{parseRd,Rpack:bibtex;textual}{Rdpack}~ | Murdoch (2010); Francois (2014) | #+TBLFM: @2$2='(org-sbe "R-inscite" (x "\"parseRd\"") (textual 1))::@3$2='(org-sbe "R-inscite" (x "\"Rpack:bibtex\"") (textual 1))::@4$2='(org-sbe "R-inscite" (x "\"parseRd,Rpack:bibtex\"") (textual 1)) The last line in the table demonstrates that this also works with several citations. To mix the citations with other text, such as ``see also'' and ``chapter 3'', write the list of keys as a free text, starting it with the symbol =@= and prefixing each key with it. The =@= symbol will not appear in the output. For example, the following code: #+BEGIN_EXAMPLE \insertCite{@see also @parseRd and @Rpack:bibtex}{Rdpack} \insertCite{@see also @parseRd; @Rpack:bibtex}{Rdpack} \insertCite{@see also @parseRd and @Rpack:bibtex;textual}{Rdpack} #+END_EXAMPLE produces: \qquad #+ATTR_LATEX: :center nil | Rendered | |-----------------------------------------------------------------------------------| | \Sexpr{insert_citeOnly("@see also @parseRd and @Rpack:bibtex", "Rdpack")} | | \Sexpr{insert_citeOnly("@see also @parseRd; @Rpack:bibtex", "Rdpack")} | | \Sexpr{insert_citeOnly("@see also @parseRd and @Rpack:bibtex;textual", "Rdpack")} | The text of the arguments of the macro in this free form should have no markup. For example, if you want to put the phrase =see also= in italic, enclosing it with =\emph{...}= (in Rd) or the equivalent =_..._= (in markdown) will not work[fn:noparen]. For textual citations a workaround is to invoke =\insertCite= for each key and type the markup outside the macro arguments. For parenthetical citations the solutions is to ask =\insertCite= to omit the parentheses by putting =;nobrackets= at the end of the argument[fn:nobracket]. The parentheses can then be put manually where needed. For example, [fn:nobracket] With \pkg{Rdpack} versions greater than 2.1.3. [fn:noparen] For details see [[https://github.com/GeoBosh/Rdpack/issues/23][Github issue #23]] raised by Martin R. Smith. #+BEGIN_EXAMPLE (\emph{see also} \insertCite{@@parseRd and @Rpack:bibtex;nobrackets}{Rdpack}) #+END_EXAMPLE produces: (/see also/ \Sexpr{insert_citeOnly("@@parseRd and @Rpack:bibtex;nobrackets", "Rdpack")}). *** Further macros for citations The macro =\insertNoCite{key}{package}= records one or more references for =\insertAllCited= but does not cite it. Setting =key= to =*= will record all references from the specified package. For example, =\insertNoCite{R}{bibtex}= records the reference whose key is =R=, while =\insertNoCite{*}{utils}= records all references from package ``utils'' for inclusion by =\insertAllCited=. =\insertCiteOnly{key}{package}= is as =\insertCite= but does not record the key for the list of references assembled by =\insertAllCited=. ** Automatically generating lists of references The macro ~\insertAllCited{}~ can be used to insert all references cited with ~\insertCite~ or ~\insertNoCite~. A natural place to put this macro is the references section. The Rd section may look something like: #+BEGIN_EXAMPLE \references{ \insertAllCited{} } #+END_EXAMPLE The analogous documentation chunk in roxygen2 might look like this: #+BEGIN_EXAMPLE #' @references #' \insertAllCited{} #+END_EXAMPLE ** Changing the style of references Package ~Rdpack~ supports bibliography styles for lists of references[fn:styles]. Currently the only alternative offered is to use long names (Georgi N. Boshnakov) in place of the default style (Boshnakov GN). More comprehensive alternatives can be included if needed or requested. To cause all lists of references produced by ~\insertAllCited~ in a package to appear with full names, add ~.onLoad()~ function to your package. If you don't have ~.onLoad()~, just copy the following definition: #+BEGIN_SRC R .onLoad <- function(lib, pkg){ Rdpack::Rdpack_bibstyles(package = pkg, authors = "LongNames") invisible(NULL) } #+END_SRC If you already have ~.onLoad()~, add the line containing the ~Rdpack::Rdpack_bibstyles~ call to it. After installling/reloading your package the lists of references should appear with long author names. "Rdpack" itself now uses this style. [fn:styles] Support for styles is available since ~Rdpack (>= 0.8)~. * Possible issues ** Warning from 'R CMD build' If 'R CMD build' or =devtools::build()= gives a warning along the lines of: #+BEGIN_EXAMPLE Warning: C:/temp/RtmpqWQqji/.../XXX.Rd:52: unknown macro '\insertRef' #+END_EXAMPLE then check the syntax in file DESCRIPTION --- the most common cause of this is misspelling =RdMacros:=. Make sure in particular that `M' is uppercase. ** Development using `devtools' The described procedure works transparently in `roxygen2' chunks and with Hadley Wickham's `devtools'. Packages are built and installed properly with the `devtools' commands and the references are processed as expected. Currently (2017-08-04) if you run help commands ~?xxx~ for functions from the package you are working on and their help pages contain references, you may encounter some puzzling warning messages in `developer' mode, something like: #+BEGIN_EXAMPLE 1: In tools::parse_Rd(path) : ~/mypackage/man/abcde.Rd: 67: unknown macro '\insertRef' #+END_EXAMPLE These warnings are again about unknown macros but the reason is completely different: they pop up because ``devtools'' reroutes the help command to process the developer's Rd sources (rather than the documentation in the installed directory) but doesn't tell =parse_Rd= where to look for additional macros[fn:5]. These warnings are harmless - the help pages are built properly and no warnings appear outside ``developer'' mode, e.g. in a separate R~session. You may also consider using the function ~viewRd()~, discussed below, for viewing Rd files. [fn:5] The claims in this sentence can be deduced entirely from the informative message. Indeed, (1)~the error is in processing a source Rd file in the development directory of the package, and (2)~the call to =\parse_Rd= specifies only the file. ** Latex markup in BibTeX entries In principle, BibTeX entries may contain arbitrary Latex markup, while the Rd format supports only a subset. As a consequence, some BibTeX entries may need some editing when included in REFERENCES.bib[fn:6]. Only do this for entries that do not render properly or cause errors, since most of the time this should not be necessary. For encoding related issues of REFERENCES.bib see the dedicated subsection below. If mathematics doesn't render properly replace the Latex dollar syntax with Rd's ~\eqn~, e.g. ~$x^2$~ with ~\eqn{x^2}~. This should not be needed for versions of Rdpack 0.8-4 or later. Some Latex macros may have to be removed or replaced with suitable Rd markup. Again, do this only if they cause problems, since some are supported, e.g. ~\doi~. See also the overview help page, \code{help("Rdpack-package")}, of \pkg{Rdpack}. Among other things, it contains some dummy references which illustrate the above. [fn:6] Thanks to Michael Dewey for suggesting the discussion of this. ** Encoding of file REFERENCES.bib If a package has a declared encoding (in file =DESCRIPTION=), =REFERENCES.bib= is read-in with that encoding[fn:enc]. Otherwise, the encoding of =REFERENCES.bib= is assumed to be UTF-8 (which includes ASCII as a subset). [fn:enc] From =Rdpack (>=0.9-1)= The issue of not handling the encoding was raised by Professor Brian Ripley. Note that BibTeX entries downloaded from online databases and similar sources may contain unexpected characters in other encodings, e.g. 'latin1'. In such cases the check tools in R-devel (since about 2018-10-01) may give warnings like: #+BEGIN_EXAMPLE prepare_Rd: input string 1 is invalid in this locale #+END_EXAMPLE To resolve this, convert the file to the declared encoding or UTF-8. Alternatively, replace the offending symbols with their classic TeX/LaTeX equivalents (which are ASCII). Non-ASCII symbols in BibTeX entries obtained from online databases are often in fields like "Abstract", which are normally not included in lists of references and can be deleted from REFERENCES.bib. One way to check for non-ASCII symbols in a file is =tools::showNonASCIIfile()=. Since \pkg{Rdpack} switched to the bibtex parser in package \pkg{rbibutils}, if the bib file contains Latex escape sequences standing for accented Latin characters, such as =\'e= and =\"o=, they are imported as is. They are converted to UTF-8 only when the text is rendered for output. If R's checking tools complain about non-ASCII characters add the following encoding declaration to file DESCRIPTION[fn:enc2]: #+BEGIN_EXAMPLE Encoding: UTF-8 #+END_EXAMPLE Needless to say, make sure that there are really no characters from encodings like 'latin1'. With the previous bibtex parser (before Rdpack version 1.1.0) the conversion was done earlier, which resulted in confusing messages about non-ASCII characters, even when the file REFERENCES.bib was pure ASCII. This should no longer happen. [fn:enc2] Admittedly, this is not ideal since the user should not need to care how things are processed internally but I haven't pinpointed the exact cause for this. * Viewing Rd files A function, \code{viewRd}, to view Rd files in the source directory of a package was introduced in version 0.4-23 of \pkg{Rdpack}. A typical user call would look something like: #+BEGIN_EXAMPLE Rdpack::viewRd("./man/filename.Rd") #+END_EXAMPLE By default the requested help page is shown in text format. To open the page in a browser, set argument \code{type} to \code{"html"}: #+BEGIN_EXAMPLE Rdpack::viewRd("./man/filename.Rd", type = "html") #+END_EXAMPLE Users of 'devtools' can use \code{viewRd()} in place of \code{help()} to view Rd sources[fn:7]. [fn:7] Yes, your real sources are the \texttt{*.R} files but \code{devtools::document()} transfers the roxygen2 documentation chunks to Rd files (and a few others), which are then rendered by \pkg{R} tools. # % * Inserting references interactively # % \label{sec:insert-refer-inter} # % # % It is possible to use the underlying R function to insert references interactively. # % For example, # % <<>>= # % library(Rdpack) # % cat(insert_ref("R", package = "bibtex"), sep ="\n") # % @ # % # % I would put the (commented out) command on top of the above reference as a reminder where it # % came from: # % #+BEGIN_EXAMPLE # % % insert_ref("R", package = "bibtex"), sep ="\n") # % #+END_EXAMPLE # % # % For a different approach, see the documentation of function ={Rdpack::rebib()}=. Rdpack/vignettes/Inserting_figures_and_evaluated_examples.Rnw0000644000175000017500000001654013501141722024552 0ustar nileshnilesh% Created 2019-04-14 Sun 17:28 % Intended LaTeX compiler: pdflatex \documentclass[a4paper,twoside,11pt,nojss,article]{jss} \usepackage[T1]{fontenc} \usepackage[left=2cm,right=2cm,bottom=15mm]{geometry} \usepackage{graphicx,color,alltt} \usepackage[authoryear,round,longnamesfirst]{natbib} \usepackage{hyperref} % \usepackage{Sweave} \author{Georgi N. Boshnakov} \Plainauthor{Georgi N. Boshnakov} \Address{ Georgi N. Boshnakov\\ School of Mathematics\\ The University of Manchester\\ Oxford Road, Manchester M13 9PL, UK\\ URL: \url{http://www.maths.manchester.ac.uk/~gb/} } <>= library(Rdpack) pd <- packageDescription("Rdpack") @ \Abstract{ This vignette discusses Rd macros provided by package \pkg{Rdpack} for inserting evaluated examples and programmatically created figures. These macros are convenience wrappers around the native capabilities provided by the Rd parser. The macros work in Rd files and roxygen2 comments. \par This vignette is part of package Rdpack, version~\Sexpr{pd$Version}. } \Keywords{examples, graphics, figures, Rd, R} \Plainkeywords{examples, graphics, figures, Rd, R} \author{Georgi N. Boshnakov} \date{\today} \title{Inserting figures and evaluated examples} \hypersetup{ pdfauthor={Georgi N. Boshnakov}, pdftitle={Inserting figures and evaluated examples}, pdfkeywords={examples, graphics, figures, Rd, R}, pdfsubject={}, pdfcreator={Emacs 25.3.1 (Org mode 9.1.6)}, pdflang={English}} \begin{document} \maketitle %\SweaveOpts{engine=R,eps=FALSE} %\VignetteIndexEntry{Inserting figures and evaluated examples} %\VignetteDepends{Rdpack} %\VignetteKeywords{examples, graphics, figures, Rd, R} %\VignettePackage{Rdpack} \section{Evaluated examples} \label{sec:orgf215fe2} Sometimes the documentation of an object becomes more clear if accompanied by snippets of R code and their results. The standard Rd macro \texttt{\textbackslash{}Sexpr} caters for a number of possibilities to evaluate R code and insert the results and the code in the documentation. The Rd macro \texttt{\textbackslash{}printExample} provided by package \texttt{"Rdpack"} builds on it to print a snippet of R code and the results of its evaluation. For example, \begin{verbatim} \printExample{2+2; a <- 2*3; a} \end{verbatim} gives \begin{verbatim} 2 + 2 ##: 4 a <- 2 * 3 a ##: 6 \end{verbatim} Note that each command is printed on a separate line even though in this example the source code is on a single line, separated by semicolons\footnote{The argument of \texttt{\textbackslash{}printExample} needed to be on a single line with versions of R before \texttt{R-3.6.0}, since the lines after the first were silently ignored, with no errors and no warnings. This should not be a concern if your package requires \texttt{R >= 3.6.0} anyway or if you can live with somewhat inferior documentation in older versions or \texttt{R}.}. Similarly to \texttt{knitr}, the results are prefixed with comment symbols but the code is not prefixed with anything. The help page of \texttt{?Rdpack::promptUsage} contains a number of examples created with \texttt{\textbackslash{}printExample}. The corresponding Rd file can be obtained from the package tarball or from \url{https://github.com/GeoBosh/Rdpack/blob/master/man/promptUsage.Rd}. \section{Section examples with results} \label{sec:org80695a1} The macro \texttt{\textbackslash{}printExample} can be used as many times as needed and is typically placed in section \emph{Details} of an object's documentation. In contrast, the macro \texttt{\textbackslash{}runExamples} can be used as a replacement of the whole \texttt{\textbackslash{}examples} section in the Rd file. The code and its results are printed just as by \texttt{\textbackslash{}printExample}. For example, if the following code is put at the top level in an Rd file (i.e. not in a section): \begin{verbatim} \runExamples{2+2; a <- 2*3; a} \end{verbatim} then it will be evaluated and replaced by a normal section examples: \begin{verbatim} \examples{ 2 + 2 ##: 4 a <- 2 * 3 a ##: 6 } \end{verbatim} This generated examples section is processed by the standard R tools (almost) as if it was there from the outset. In particular, the examples are run by the R's quality control tools and tangled along with examples in other documentation files\footnote{In versions of R before 3.6.0, \texttt{R CMD check} used to give warnings about unknown \texttt{\textbackslash{}Sexpr} section at top level. See also the note about multiline argument for \texttt{\textbackslash{}printExample}.}. A small example package using this feature is at \href{https://github.com/GeoBosh/reprexes/tree/master/runExamplesCheck}{runExamplesCheck}. \section{Creating and including graphs} \label{sec:orgb3e0ae9} Figures can be inserted with the help of the standard Rd markup command \texttt{\textbackslash{}figure}. The Rd macro \texttt{\textbackslash{}insertFig} provided by package \pkg{Rdpack} takes a snipped of R code, evaluates it and inserts the plot produced by it (using \texttt{\textbackslash{}figure}). \texttt{\textbackslash{}insertFig} takes three arguments: a filename, the package name and the code to evaluate to produce the figure. For example, \begin{verbatim} \insertFig{cars.png}{mypackage}{x <- cars$speed; y <- cars$dist; plot(x,y)} \end{verbatim} will evaluate the code\footnote{See also the remark about using miltiline code in \texttt{\textbackslash{}printExample}. For figures this is not a problem at all even in older versions of R, since all preparatory code can be put in a separate \texttt{\textbackslash{}Sexpr}, and then \texttt{\textbackslash{}insertFig} can be given only the final command producing the graph.}, save the graph in file \texttt{"man/figures/cars.png"} subdirectory of package \texttt{"mypackage"}, and include the figure using \texttt{\textbackslash{}figure}. Subdirectory \texttt{"figures"} is created if it doesn't exist. Currently the graphs are saved in \texttt{"png"} format only. The sister macro \texttt{\textbackslash{}makeFig} creates the graph in exactly the same way as \texttt{\textbackslash{}insertFig} but does not insert it. This can be done with a separate \texttt{\textbackslash{}figure} command. This can be used if additional options are desired for different output formats, see the description of \texttt{\textbackslash{}figure} in "Writing R extensions". \subsection{A technical note} \label{sec:org00b2a6c} The above description should just work. This note is for users who wonder about technicalities. The R documentation can be built in many ways and as a result the directory \texttt{"man/figures/"} does not necessarily refer to the developers source package. Indeed, when a package is built, R works on a modified and cleaned-up temporary copy of the source directory, so the figures are created in that copy and then included in the package tarball. Similarly during the package check. On the other hand, \texttt{R CMD Rd2pdf} and some other tools and R functions work directly on the source tree of the package and they will create the figures there. The net effect is that a package tarball always contains freshly generated up-to-date graphs. Developers who never generate the documentation by other means may not even have the directory \texttt{man/figures} in the source tree of their package (but it will be present in the package tarball). \newpage \end{document} Rdpack/build/0000755000175000017500000000000014203665045012714 5ustar nileshnileshRdpack/build/vignette.rds0000644000175000017500000000052314203665045015253 0ustar nileshnileshQOK0n EQDvc ^xVn~l}iM^< { cyh#d/@kH@dP"Y!쾃%"-51vJGz^ΖNJx e4m傒?+1`%F\ v9ҷe,NI2q'ǐƵxZvV~Ls^ bءyuNj|H]fwlJVW;%cX+=)؁ّiGLY7N- <i˜)B>~D>|iݙꐼO]t|(ٍٝ1hSMbYk!c~AC6_xne uZd~۶um? YVosʙxU?pUF[^"ĸƆ̋T5<a+^>9J%+I-:ԏ间 xA㦹T`*-9Q?aSeNůxEU)"|8yƘ}gW)$r'桳fZ1^P̯/+*ה{(MVzQoռgN95بOZrmS+&NЎ4gBRxĿՔN5ed?bN>I7 _Ȳ-B7& ë,yw̢j_TY)~q\1V\rOG%F͗eRGЩV 3iq @y>!MhfʟN*Dum>UΖg{ qs\^[9F֞Nyu6m-z |R%iў vKǎ#Vt#y5,69j(J0q~ o!w}Q avp7*J<  -~RX;sO왋Xѫ$-v%O_V=鶵Tm/V-N1[cџۨĉ܃Z*.ё#7tT~Q}11v6,>YzNjM53,HgucIvߡSnt,#l%NQP=dD$).eBѧKh]Qi4;Ǿx{BK8 ޅ|uJOI4$njY}֘M+^N3 ;$cX-ψN\WH:*+eQaeCGKՅZ}CA\"wx@ lgRVS<@6VA x\rIKqq-T+m#FXCXړa(5cZ3kT秕[.8^||t?r/Yϝj.rm:+z%cstk(JeVWrRkfQ)w*eT˘TKweio.Q7f2WT|x4W=i|h~^l{ꮮA)dlL%Co]oWt%  F_2.I1v6r0mygk\/mi9~]N"$Ѷf-h5}g܂X \k[k:P5(QԿm*X2/NX;q_hvO?>7[ɿ[k\X:MyPYK;b O%37 E W+~57Xsw//;YO|:MkwN?X&Onܲ-W3\ݷ& }L^}~-}k޷6lUpimj6n|cʎ5 ֖Rϳ*+ؖ9rjӭZF^u.+)ݴbi+msk{o͕iQZ 隲Ϭ)l\V/uG_w5ׂ6b&ž4rYC{nZFgJɕrv * V~4 V)ZJrpOVC:uzorϿسlPv[1enͭ޵;[F+uU_ o/PVݵ_?նBª[YOf"gVnךw2[ƒXF_ڞ-}Pms+Jeh.-Pnk^Q{d;q-?5l>} *y"lA$EIY5mcr^CWxflHvM.$nN 9yE۲fDVT M&N~__"nL;`8\rwx6ҰX;a|&,}ˆ2 pX.mJڌJ%kF.sby}[~OǶUGernf&/fnU7PS4-`Cb=$Lӥ{K7㛶n-lkxMjCS\hаŒ1 kUPR_/T3n*x,5!j+uJ'u?36E|m$g;TۈgF#ԍpފt7ss[u B|kQoKGzZ'VBrəz;Y9xm7pqgD X=A,ZZN,-#W8zNJGS6'#q-4e@{VFW*y.g<)s<^aI),ő<-`HvTV hv, ;?%+V oԮLLxO-]&\ wB>j'#4b/ft#O5w7ujnp˾a,x}}#% <YoNtD$/.E~5|nNf)SƬXblQ \~Ǖ6K{0Iv)"u(PU"K9̬uRvs`rb{8yȸP;QYv#-JI9>1+g NױA9>`}9ٜA6d%䤱S\JF&48uJ4J쫔NnB&ltkV\uj.%ȗږl:6 fg2[,"\w!/z4ԎY~ܨĦK3ǸQf3՗ j۱\X"gVO^1k9gi-f ]ZjfRq7S͗=Ɋi=yLw'oP`|Q^5o9Ũu nNC6~3LӛR'΂rVv) :mw~,6 sbŔ"sBF9b!7|ta|fLFJ_+3 (U_$f_}g[vVْee/H7ȣF,RI{y'1im̘t̚ʢlB֔?`uE x늊2̸ƾeU'kr,3u2NC62 Kviy&[T"&' w@C@\$]ڨDx)V5NdP: |{ ǥPBf Qvp3 JkAUzgܶ:;1 vgpyWRx;Iֱ#Ͱggkkl^⪪+B# u7^1z;7Ex9N.d{|.W#J2'RoAiϋ~۝!Ttx_|P՗S݃l sSFNX߄ oܸԗCCCS/[YTF u66f %NrJn.qf}ڋO_`̓WKnȾM> 6{'!TMƎo4YsjA/.ё#JpJ}J%eLx0̘Ǿ O['.q: YRTyܠ/KM%?A7v8Gs# dc?7OqYu g%gux[RɄ9ސу8^bm6zP%iC06~ږ*_S^V0)њS˼RRx4{L g}k16!m\ [?Tk#h6ջEL&ST8pYFQ$cH$wpW VD-n%2tt._"ނ| (&4nT!"LbG2uaT\/(dMN%o ؼ+Lr,|9l~_Z)C%DC1KK=#e`6o|3]W.yh{":}Fa^L#T\/p vbS7$qžeE %D+S8[Z(vΗ],Ѡ'}'Ӕ=˦Jq%2W7!ߴRl[ gۘ5.{q/O(*Irl^m r p/ j6\/m<mwglZAʯ`ns`c .U3E4A֊ҶFvo905f0C6V J/S>PD36VrQ3R/Kǎ(l/_~\48ͩ8'YYkc oAֲ 69 vk"1ܮز/pQwXxqqG7rdYD41Z- L^eIo ]t ,4,ci. ʛLŃJ2P䈎jAX@6i}zOiCYݥ*}m{^2{t^&? Ƙ@=`nQL ҆֌Eqx=sF #O&޹b;vawc;?^$9i|fK2 )T>uQj`cZMyFyg)phU7(C+`q7 B3msܹV{v3R#Ry׼F HǐZa!q(|;9 XRswW;錰eso2Ql=tun@d.}x WɔV2j1Mf,};^BbXd| MDx -8 "/cc|y2[ʉwS'e#< T \8s!nľ҃MTPkDU-[!xl~u> [v*M(jrL$<1ٽs.^ ar|j?WWȻjLQ%+#"B噶rTz#YV6gApj+6Pvvq6C y1_=2`L(nyqN$lԘ?CAȃ]hOPvvڜI̚h|q) 2̘uwdCn )Jo询:kV;+:7ZjgH(Exϡ'bÑ2w8tиҸ&JSTe3u7|P95Z`HhoP>uW)'TK7,!SֲT7*lߺ#ϔ8A ]I)y0[f5AA]9U1HKYDESmUWϦ2J(/S&}uC~~Y?:'\;ַó6ѣOó?`aw篾{mXl kay[T?z7/q~4e-&堄:0F%U--kO!v[fR&ע=<% Z-Jk^[kfX[cun~#7Ke*x4hWq@֪%r'.s?$!KM~&E3M"],wI~ Xj&)hy66WWưh 6Ýj*~@B<˔[Bi֊s2 i5ZбΌ(5;=%l "رN̰S+^졄x:^RߙM/x:^}>㊖?-|\-J=p*^VgK_;A~EʦϘx2RX5Uhr9ez[vWvw=FOǻKf;lwܷl96JMB$)48k!=r(7(.J?Ԇ_\-]w,ϖh/XŲnxӘh19gW2]k$ _0Mѿ zl,>?s!. <&=[]S:s)x')7o¸6nď+.ҟ)}I"C򇨖R+bT"rz^ ?$g6ɤ%cip9'"VtM qЇ4mJܓ׏:7 US.k YkÁʛ6W? M#Ňb?t{\{2{#~E|JIm @[|75N%!WlI%໐59U\ m1T[SLJJ'hG~::M\GG;T% OmFazz<:==NЎNo-\,\V5u_P_4:zx(ܱѱ:dCc;~IԱ ilxmc '#.T% -{Ej( ZR{r7ƨ~aM{*Mo;1|] Q׶>.ZTU -Zw6Øq:|+|:||:}2s>vytǓ7X=WU^뢄x _O}+ ޤoZof^Hz1JcchDixLƹ8JP4ļBCk՞(ⵡwF/'utrעt:"< dk?%!C;3S)ԫF\?bwJt8<,P 2VF5BJ5 ˤ,b(E.7~ꄑUįFnAQC/,Tjr<~2GCe,G@~TCw<`e_5tljduJݟeȿEB<]NҼp}'A;NH}7+$*!A;~BUhRoڢm\*S"Sq; ]?aKG C+t ZUa=YdDًK=,Fm=s)e|ظ^&ѫchɯ-.y$Q7GG;X7!{K^Գ U4Ԕ#" <YkhRÐ [r-#SF^k# tx晷䭋 Po{,~!'^_P},M^͗8Q<]#2,ݕ%'R}3 Nx -㗘N~[b:ttP0m&nT JY 3[jsΘb)ϻ:刭xsjOAׇyJ7(#H1-v3XȆ#Wo9_TΖ\sG7$&nJy ܍ rfk]{a/$ !f|7y Bk&o).ER`Jefg kݡ77[i?"u8y̘Mƒ;+4Q2rW91$% fʼ vw&Da8yʘdMAha{+┿-=ÐK>]L)u#ƍ|6M&^|K.O {ꮎg\桝|l$k 'c zݿuQN@V^7)ځv#.>}&~`r^3bڔDcXB <Yk n&yhC㐏[ky&)NAL W<>5PTDl8wcͳsU?v젝C9yJJū*IU dsUGJ),ᱝ]uJ6=?I2BR^-q$.-K\Bdq5et y^a1/(K+P xSyp.lGX;88Rq}T\/x>8FKkcO҂b5Ěݨ܇sE\:lx/\7ۥkfq8vVTq)RBU:@Mt@r.UTAYg'kWRӌns zL`_[S0ȠamULb,[%fɖ[r= yjf@PcHHl"ݗ@#:箦 )*GE~9cs4Uԩ tܢ{U~f#GpyƏT\/p/d=O5ӫMfW Hבv"=P[r+Wr n7%h\Q^v>.>\vƃ؊`?d-KVM^{,iljGƅFOz' l7w gnTąrE=:~St~)U<GP>B騸beZ6Ytn͢vpSn}ަHUOy;yL[LQ .}fy>oYqScP>]U/GC/{36n6-D CIF:L4@cL2~XKy}[?+ybf(H14Pu>ѹYBԎ{8 [IE A6_ާ`G\bD!|-;w&WEdL疔',B{O1h5sLwiNH+ Fx )fL fW kroS'>t6 #@#//^_mk ɂ(\CrSt7~"ZOT\ g?D,/ SUXt8/Xү6 4$rC7ʒ7(tr甬GQ<;Ґz0tі6ˈm=ZfKRΕ>Q;C60Tx idb홯~Y3>< Y+ڸHwRtBtxd.G -E 7)zxfN#IA!kkU&Q-½cЯE.8!%R\(g\D(Cxɍ7ʨ>)ȧ6~z 23֍3`F+x4%%ܭUb[CUi}Ԃ_\Rޯ:Ԙ9lWOFM-;px#Ix~^p&%:x$K\(+ʕ 726wffrJƣS\m<-{[a:H(S}SVD*[?Qq!{8ZU dsfܼcxPղ 桭G /-"&4 /A /zRmP>_^t` ]ȧ8>0amI|fT(p6\J\_j[l/& m p1qݵS zN8y󦃋c:h|-͝/XD v enb<2l *x鍷.YYc8*"*\NU{{"n K(3]-n(ʄv8fK3V%U' o##[v+Y!GSY!TO/0 "ehr֝[N;&"N tW2,-V cj'MPDl:*4/rInb![~}"< Y9yxyZ:1@ܘ!R7^M w%FI2kGvx8i%Iyl 7܁Te4dAߓ!BfDSJB x%//RXm/26SRFq6ɎljB"0NКaDjP.igRiL^Vv&O#xB{[YLpjEQ#<Yo7f]-ѫf_ %z7 kT!{;b~}(ށ|ǘVO֧?$4s3mZ Wx=$""ͳ&IZۦmZRTN$d<WB<439̲3wS! 0G Z pN|&Ĩ~Am~o@ho&WO1=WNMON=zT{m6I.x3ﲲ_. 7^^A$L&_=])IP$2N /SP-[otBƶaVVj"XˍipMSq(:nX~e@%V -!jL'^L~*p3Iۼ]N)~ rv{Lۅha"v/]ZD퇫1Ն4rC¯A6H|Tu tE'hg{Kh"E?7 d-=&[PJ9R'V!kFRF/>*n+z6'%ә.K`Wx il}EC}ЉM L29M*INi_^PUtZ5~?N@s(21-ψN^{7|ysP*ƭrddT0WW+U!iz,@.t*B#}e ~!;tEC)Ǽ"_ nDrc[j:Bn:Qig 1n8 g1q8yψ,%->snd8a \נȿdU}^9q3Hy5Lx6xaC"-f^{8~?!4v&qej!-l~vaaCn/lLۅhf@ȓ<&V-C8yt3ܱ`V@IqǦ!^ kugQU%":o ; (od6`tkko yq\lu9&*^7dJ{e!Iy߀:lnavn([lժ)TeM74E\/_KU}#z7!k ۟zނ|˸ p_9Ѹ \N;x.t{Y,td=vRUbrx־Pq' G9hGu cZU[8FXXuނ})/!G\qVEmHm%hJFx`f>[(:n](Ƞltα3vr8)\82BrL=L < .T|VB<4h۪~9 "G]04$!̌YnczF  o6WrL`b< T\dԑ9\8/ΓBQ/?Pq=~1bF%1/ _u>ҹmTo@&E㨸 ǕI^-{e'P(b24*RK-lOh'dS/Ixy`#m:4d=gӁ< e7ZZndmxjͭn##vB{n/e1P73c/4ZL/U-0"4)qSQamK}?@'cӊW^LP=1ql,IW.й(f;ŧa n:O ^`rHxQ#G^k fTl~IBme 5|#Eh=|C+ ,na#yb>ኈ!!٘z?im午JEcE vi{(Yq|SZX?DKSC~Rʾ8< knGP2B{ξ~S5)B z~ԭ[{ ZF[z6"WV{F$" 1 A;q6hk.IU1 =֪t'V}5ނ|ˆŶ6Y bQy=4gB/R'HǻxMGno{B{c{,zaåcɍʑh/S5N8yF{8X`X_r՗JHm G-ElS, <O6.J=l@g.E'hg䈗Փ~[f#"?h8)mel99Tu忄~gŧ>}^ > ܰVӎ׼rBesقW(ҞBd-b Rp+r7gccXIMrO왋<l[z?;lf*[7{ǏfLL~Rۀ +߰oX,}%״W%gt_`# jhyykmj)Sl 5Oy *slI<< %]}D%DkiXaH 舛n3]^҃,ɗ*8!rE d QFlhHn2GwWPsq |%y_~^9.1&쁬y`B 6ۀJ?Vc|Wg|HPB!d* |8h9^%vG;TО_:c8зvҷcѸWl$gֆK! #!NoI?N nG-X9'h w C=nZD ! dlxS7ML , Fd;dD:pNw x5|7ZzIhڋ5)"GI7 1)v6yr#pL-CoZV/C '!/h.^s/b%{i/s7߂>!iV|cbre>QP#|Kpd-L5Ӌ۸I.O,<2V\y SI@8L1¯z -a?b`ޥZDaV%RteշA .4:#L Ge'p=9 B6M교O|eL5Aqɩ,a> E f߼*.ml:1qP'lHDxƥ~?B oC݅BلoʌA\1^-qAYYFmeg%~=xJuC>ߙ9F$帓/⠑ n1kͪ")OSXlW">2Nk$ZP[,7!OXcK}* Dx^smsJt8yp{%!y$˟6Cɍw _3qpLB;C" 224KrЬpG'~V)׸ܡ-nӸMT.`Nzgi`tэs(g''7>}m߫-N@+hHWl'"ZuY7Dsx97W3.v( )9Aq.] eFmxsLR}VM^q JLVTni![Hr@v4MnQY3g۱|]?4N}^wm4nhm Al!U&qA'M\ а0nqxt $&x|' 3(% R+_v_YA>.x)PoC w4O[_< l:X49_5&iSMҋwFo}!6Xz8QQ!u3 $dBm&d5ls.BpN;>C~"Su85 4[ ~ t.i[y~R7*Oܷ(uř/2l ;o񯳲J~9oOk_KnmGuBuR.ƚ[y*}[|$j3w'Τ`:/vQughf6fIޝ5>mK}cUpGSBtwh8$%\aTWL h#9YF1I '9!w4w8(fo if>q L[~YzML~"dV&B/ЧO y nz 1~ < qK֝0/̓FLT[^ p^șyk|{)bBvXXe~x #72, (G)3> %V )nNC-,*-8*OQ@K>X%QYrV{:;i-Q:4:QS а.Z1/Up^}'N-g?2!Yvp0p ΟrZ2 \cJЀv$#BK̠юFAQVCݯVH{GKR;vW8 /V$wcyX\hIY½HV$}M8[t'5zxWznV#c3*q|Ŏ|_#>9|xd ԠFv2Ϝ[L/yjiڄ؆FoF9f*fqU<ոX60 ,H¥ $8jr\{&ɤsʼ %dB;x isʴ4C-Z9i+v8'd w"~XעЍ W@"7>Fa޳BcC{0`8cMVlT|:rħZhBFݷ|0%ڔFMAhiTQ*BꝚ "dXOLTETLDž\o5&e%7S|JBŝl!IG]xdx xL6g>T{q/d o*O+r׺Ek4H3q,RS*h'fmm%ZS: Y3p4%<8&E?pq7`-z ^:!9"Y&Y lV$S1^a?Go<.b9U"j-[Peܔ j2&Pn)N قj5i1\-TOFΞݝnCۼ2"RqǁBDžlZTJߦvOµ,N&n#填\b765d-eFyaw>EmE昅zeזA\CB蓢ZT`A}vû򪲋q'dBCNf*/ܠ)"hY$#D* 53,ɟN7_+چ k"R͹ϫeXIDUmbzυl(0`Kh[B ǿ$Ԍi7Q~`V5L"pxNȚ)K/CCVN1KBgYy|_cз[WUܠH{+ВCB֛<,d )/rO$3Nbӛbzu?RMtgLhH/tN=!JgM4W8Ŀ9Em Y=%B+S1: .EZϖ㼯 Dgp;< < d /}jN9| rL!Ieª Etl.c[\Pڔɂn l[AxmzAL?:&.zF=+4(;"3D6$X.ݒ`T\vK*xDr_AVBۀѝOJm9k7(pB±N0FK~) 1@"qT#%Z n%_E*^cטfb#[ɋ2⍔w!ƻmTZ<_JgFh/k/ vm<7n\|=ef!nK jT!YaGznlYq "QUEnFq|o*WsX c(ѠF>ͰC oWOɆí] nFsTO +jP1ZǧDž oa*xB|g:ԳѦ$pF5<^^Ė( D/76*~Kޠ:E"^g׹ʒW\jYPq..O~+Fqށ&f94] '? I)/`!<_@0s M,nDȢj"z^*-ڽe,BQcZRsN-Z4R)~(Df;p iP WȚMAlaSCy[n- wS"Q.;!a_ e/ u k(J0MW.}[ȝ\ bt{!_QhRp+r7gcc˓Tʫxlfgh6|x)=x˟|t_&O^m}?}019AJmfBV @R@6z;̪#G5D1-󸕱Gy$O-MR#fe.W:ָ76KQT dž'g'fϯa8͛<%6ZPXm*t2)߹˟n8߰Cc߅xsj/ClPyd+ܲ_uB2k΅jjn5oޘ*W|,ٗevǿ_-C'i /,}еSOdsȦs7j OO],\TxW9VFuDHFN.MXcto evk+0fXe"r*QC(i7p›z/LJ.aVFޕ`2w])(7Z@y`ψ keS?KLȋBV7_<9Y{ox7󡯅Qߠw?rMԻc- q _ẻr_}H|_H7H%G@pGcI<[3 [uGA0`Ry1c&| ۤ>[4} P)^̏ʃZQ;j/4р0si4h Hi8,|]և$49 -f8/6X2do޿j^jck5ѾV@_2&~orn?OH<2x{x{:/Ӷms%vg%eR-o.9hS/ ng \i Z8V2bp@zX)]]RJɛFۅ@s e&mov6?G|Zm}[rux6&?ziqx_^xyk^,DiLgwӟ+.Rq^[!KUIg~Kn˚C8!zÌV*??cѢ =?x4i1J5*w*^[kfX[cx;ZIÝexRѠaKiYbږ֜S6ӱ]2N5KB<cB&r#o#"^4,6VEvG AuA XjRc6Zf䂵9WrbUu%MaÝo3*~DB`fL1x_oeyT \:{,S7#Zw^*ѨS_>KƬqkJkmX{뫾M?ހMdypˮh)ަ*Ž$r̉E^=Vf!ů~rpXYKtXzB@>bn5*[TQ`o]CcB3ԳxP5d7̻EٕLh]Sa5Uހ $8 WݭTmĤmF!?7{36 l&Ӥ5Y7~\@geU"껀3mђapK![`/tAWmWsx(cԹDP/8@RŽUo/a0(^|asDbVLTMv|b{>! (><Cلf#} >% <j7TAn $th[0d9]8v2Fn+6%'0'LJoXn)Hأ=`NWs2#s&=mA9Lf+KOiL pĴg6R].C+IRߚDuՓ(i3ӯP݈F5~m[y/qB n[9-AJ?!!2> K%sn^CZ}yu@>`MgR ^F|+?,!kFUj(432C. OG 7B44cq/VRyZ0 ˀλ.VK\҂[`cgRlpåߨV{vB6nJ_–+Sշ~R>610D6fw(Hhf{]:geogY-K5%\?Fٚrٻd,Q!Z aAM^$ey蚔q.Pf1:!ʴs9tYx?/1UW7nL1b eM~=sn%,2̘&-ϖfKw\!b_-]Po`M&W.k>Ǫ0^rJ[^(1d1y15ui.]Kk\ ~C;>}t)?eAf4U"dGsKB%h{[O Hm.iV&0\}Rzc:lيW8:Nr7|d ɴDv朢C CZe:O@2ږuN P)oWkQ8BjN&ՌHvIŞ^|&z5@A6-'ia{2];=ME$cfZd c,OY7=נ'!tik ZGpө$yR:qЩHOavkk,fCss:Ru%![6!4m0akMZ6w:<#Iȓӓ꼰^NA2汙:"9Ҝ/gko$mMU C–[TN!Fw&8N݇\v@>m(δY%ȗj{A<.!wO쩔HxNIr&yl*~x: ҉Z[L#vb_p-;ϽerP[`8 Y|QS烙Ϋ3QB<Wg90ƩsomB*6onInμSV>gJ{c:l 'HsZ`QiJ%l ԩZCkmԍ t]ꝇ;ͤDxsQ-j}]gӾ$N445l9mY _L%PCn@;qKg:YǀS71N)GhߩRٛSՅ|ظqv*.킨| i<2d{3y໐5odK? N`W k^̗ol"}tB+ta$9oEFjNM"sWdBn`XYq 4E웵0bJL}ރ| u ZtjC4\==:ittMS]߆A8 < 8ȅ410a9J=ݫ^őJF3gM0Vm\-,Twaټ[Wt,Eyd2 >y iMh|ҷOp/d-B5ze vO?$4+tc[!\VSK8x>b}c-7=_O`I`Cg^W>b ʓ}[Y6ŗŏ 6^YR|SjL(rKz;9J:^@գ -n9 7Nќ38R7>>B# ookhJԑboOE; J5{m_u^tF8sf!x<3{tQ{tIl7[D!/=M!ZP n9"u=g LoˣIJ.8436sg?~7Y'G5:Xb["0~lՍWL"Moٌ^$]%F)oH^IREWmK%aa|jb˿]džxW'ɳI:cSNq ^KM]`8ϼVqn:jrڕS( (Ej2|;\mJmy>&J3lxqy0-lNmvzLGH(V@hv_٧1u B4xz~T*0#EMܭDل={iٝ<٦o`Rq:H:b{,hORsnhYyB<%ӉI6nlNtR\ބ| 9 Jh7,>`O^@¾6rv<ٞg!(Cޙ:/lno+0^QOe]mD0@pMLrېowmM6O gm({XQ!ky-n.0i8k,9A[:ɟPngcړ p ͣޓ 9Ɇ(tcT߰a5 HP{êmJnxvf$coCѶ6 -|E=g1BBrBVRcG7F2Z^. kMtx Fڞ|yβ[R=d[w x1uȑ,Å9rPy$w:?]F 9x#償H3K8ev>*n+(d!z[o:#1}滄giC {r%#,5[sB֮U/$_N 5#rXhs`c .U3E3bu=lsjђ DT h6fS:dlRLHCNrkGm۩5 4h[^iJۀ 2Ȭ=F29ⱶ;.ELI.M-ԟZSx]:&^!vXb-xR;?nRʩ66"<`Ll\-y\.jP:!m˟yM nnȻ7N_+~vV h"{$liB%tEJSj/V7dB-%\eU&~d_g@hϱJP>ñ1^-_@ewAPZR-0$t -r Eޔ\H_%%(ϲstgw17rΚ4^`Y6|ZT7Cj`eZ՞/<ӅRxĶWF}aDe([?ZBK_FHJr49)R6yKW(S:ae'h/>x ey@F\ QyS.Pf>J1sbV+b[rH=}[8Q-Pb&XfH/>|a>c>&Ի`D(+6dw%X ުiZJîNNWBFA:oYca3bς'eGjGj8fo| b'!km5OGM/|L![۹KQQq_:[wT|x i97]]ҋْa#z['?x`a;r@>JGFmq5}8s.#NDBkM%R&7 OB<4;g C(%t%Q%ģ%c)3xLFc|o:.v6?k67ix6&?ziqxl[xyk^a׆p5WHWy7ȣ(ispޛDz8McRP]o,$u--kf܏O![fR&C񷶷Dn<%Z-Zozoogbouv람_OJ%O;x؃ < 48Y:ۀ kUQRߚsʞA}4M?$aKM7 `pj. ߚxȯzz w_&ZgE ބ|Iߒ%E?we5J :#9y`ӊ6qham8HQ_4mQYuX?^Jjږfyo&ܼa[B܊ThjDU(i6cА.('&\VUJn)2Xҫ8EXM^_Kωnv"̬ĮD}تUB4N/@ևa6{MԿ{3dx:7Kox);^kt >]Ă).aKdNa4HvG{AG26;=_ԑHfքݨ #6Y-E/^ʃL=(w8t0ԞИ#zd/zN_ _,}tv=RYB<ochcV96UB7&i,O&{!|N_1]펡x@usD( g;W4/21S(BMYpU4:}VNN@E #&y9Q<"79~eĽ,IBC';!_7&X?XP5Zb&KnPUv>ZjDml6+,BOE=s&8R\C<oBمt`48!elF:J)ho,:gNVry?D C3 .wcӂAI؆(᪈H;*bPB{=b.ZUTp'j%SNBrVo +m4 #sңJW!;clpy )Q:(R"nMh>5SB;^[?").|Df2;e;![صԩ(H 1,AfMs6nxWEdz_w i]ZfZrC8mQ:tSg\GGЬi͊<Ԓ dJ$gYmf$ہ͝O$lՍB)|=r 7f!g7~|@>cn[(8AֺsJR^ϬIms>SϓԚ@YmvƳF Tp1+I]'l(~Pߥwrj]_rFWrB/UW?V &4ۖO'޷^E*~^f4F'حU|Ux-"u#6}!;pɯKC  #r U"{ә!MƔDS#'dSjDxɍ/*nG}GFs)I 1Fy=%lgm۬N\M.wↀczepNA6wbtSVR| = Ē՚JS>oQx`*X&^8-M䣓 xFHM S՗) /C6h~!<% p؂ggֱKp (]rş Y˷92QYФ^V\Sm<8 YWS06eq-Ehlk"t"*ggFƄqQ}Oe.(bJkG0"ZoUiV&ɌB_9-h\P4TU1bxٍW1*nd(ӝAFs^|# fg'yn5аyr-YD_S!_džU=(X-USC9nE=W/sIG{F6el\9BdS {3cYVt*u%k7$NB63Wl+y-D(u4~W].tL#/z)FaT\_/{_wQʥ\!7桼+gNsc[㸳i}.R|v:,%uZ;T\/pO|IUL`~mq JD"N%7g ?ֱ1“t͆1d?ce]\j(2K-,=s)e|иVk)X([,BV9"1=1ar*J2&ק鎧f( <YljKk40a{u#hZL8Yd})7 ZaώY5yxB_3MS Vr W$-ݔm9|-[h7cwV<ʮ~p7z_:BnH@6w<+J][\UY=BNno)12D~##ʳ 昭嬲0#Pgzѵ2ȝ,UDS;9<w;"Ikͤ9r 52Yf4 pPg `({T0pH'Iўu']MMXT`c^{'1bpŲ*w!/TGr ٙmmT^NAcCZ2i+P敖<[YK^4jI:6^y^/ђk2nF8|#E.i$M+ xr6Ϩ#7ޮaKbm(pYPl(G^$N;z3_v w%߅ndԶ ږmaڔ|͘lVT|x4;)/e~cv2NcJLܷ[UIG8 yؚ5) S_BYwWއ$hBoyDx:n=D<̘k?6}^ >#gy?-NϽ0 sقX avp7*J< OrI\˿|R}?}019AJmBV,ohF?TN$T޹|"ɫ7ɍ'x\Xvрf:oj>]ں.-5r)37:?#M[*)vڗ̣)g$5s!w T};]2e`AtGIؕt(Hh6~豇v*S"3bQNx 1k uΩū M@)m?!!Cα/%= G B3[z Cαs$UR4!LVLDNNs,͖ZJU YBKa"ΩWcTB]ZQ=Ӽ+}y"wǬſ ;fsEۗ/ /F5IhUV{邚}JHKj T+A;j)5&:'#l:NLw v1۸@[r%/$D({6rځZ$E<w_E)@@p`,pSAHcì6Oa=WZlKb k>.5 a|2ߎ+w~((^ I(E3$|2&,F>00Ab'!4&y.dы2 %#w|rQvvƫ޵ޯ8w+/i/*c.T۸ IsYCqRl{>CHblzZx!hZkm-VW%$<|TC Qk $KZ1_W77">,岿3){L ʄҵfCbTwΪ5:_ ]u)|ʖW3Dh;` VRAC2ԙ:+ Dxh޸" ~>8VZ~SzO@6?'Q3Ncbnc|<Ȭ,hbm@o=n&'ZKA((㥉bً'x}>.N{N8y= ]E~"`kHlUvHլT[Pvve\_ *}yt S?Gqьw89^P:l05!*31~ܖ68ZiÖzVmoR R4^K{b-?[ "gKm8E?=t)Bm}sXަ诡؜ϙ hh{8G3"?^{˶RJZ4'?̧(QcԨ+=zooGUbo\xM*p) VJB>bLO^vM(At:Vh.KyQyVn0h{܈z;Xn |~QFir0~p"l=h+wΕܰxUԛƖ1q{R?܋HЬhKx>k'h K\Ps>?-ZyM SK-G(_SAK*`WڱXѲ:2E.""J.vvG*x:MCla4jJZti`N^E b"f:t[]N)x w$*x:ygGR--z d8,[\rA6g]K9eˈ>-H/򎥥ݤ-fp/:RƁDŽFp<`,'BJ;%<҅AB &c6H czQloP}%+Ɇo}.0j;ib>.-&N4>Lʈy5Ђ_XNt"W"<<9Q]u" jCېooD@]N@0nŷkU"w o `͔,\tJC SC@E'إQʲl)[ d;? b ܠj/'2@~g{Y*+b0']yVy_!cZ <*Oܷj~^r0~)zf7fKGՀ/;Q䖲/PjW(U.KPM_`AɗXaэz?-T/,N)z26ƮR$z/uFB74Ju]#*r萣+LxucS}&S0KnH77bˆc-b6k"Mr*ha(RzlJ{π{ʿl޻3js-;4U|xtOe-G"[Sk#|:nz0ﴷ\D-<5UI]2 dRm@7Ҹ۝AB:$i㨁a7QMc^ں~ d1Ѭ/9~l9)WrJN\dFrNi{~6jP mF[5/ps"eВ`C؁)<tCgK7*.\#TR^y7/˫x=s˫cĤ]|4Mbψq3Tޒ*/ y>y*sOC>݅^#]Ƕkyrx[}Ir283(d+2'(pawd@%"wv";^JsE֤!?;J+-bg>iQ>-Od yQvۜ[aOQ掻KS|~;zDKg?"ϊS~< 9Q, ,%+h"v]T!IxtaRy̢hDKi iwxI' .5c_|{jp{ Ҿ!1se*xB{%T'JhU!r^{=dWCJi(gMJvs}펡=9d G! ͵h{CYN$ہ'G^j8esa 3;u0$:ޞOPvvړeK]pj+v2o)ȧY,-^0!oqrم ,=0BkSX !s]%^rNa6 4jYe%"giwAp@Ƙ1f0m"wV׏u/]99$EJ@)RZ@u|R/2Ӫ-!N!@vZ96[o沒+&a#54*]#u-%eEJ?i yAuSC|( CG%o"na_!9SG:_QTQ iJkL^;aיZm$ ]7Ok>eDUB78^52,8%Uo-SޢڙZ6\mBd*Vj@þA xV-5=Mj'SMC93ÛtRtCVi뚤XkrZ[)JۋKR{{*0E4IBb'%TQ%ģn={M[ulcY-\BZ>Jg^Axi=-WۖLӲl]G]Q؞>If_:2%}؋b[T_ ,aKnnVXw& j}FFL a{Ws`xWP]\՘_?m6kvm?>A3)v tVA8M3<Yk,eHB! $nɟ'Vq@$J+>PD0pұW,xD*EwC6Anw=W=tFz\E'ږ^=(-%t*fW˔ٌLЎg[L'9ʹL'ÛaG]ZSu'o|̸}HX_S&xE'qԝ0Q'y8Z 5 EGYc<9:yh aoAl{ɩV?m[jz2(+%^FWSvҡ]1,=(zB{>sb@\V)o$Rtٷ|ΉA\$iQV#Gx=8Rl:{drZ1g'" 7BbnH~~*Edg X;GKNDkx쐭,My3-9)ԋwx`Ud,>t햄gkq ڛ1+N n) aEFÙ"lBPϫgT+GxPʇQܹ-_x s/\ x0;8Z~E *J!^=oZܘ[`ژF/p/佪A9A|_ msQF:% 39jit,ukyTܔ9^ȟc~EsG7B}5|w_H誕 ux,UߎFL1i1X7g 'J=-gZ i|G3%lװI;j&l?SKş _KrhoV/ 1q;w/X<URtUCs%*xLs,͖ZJ[*7KhS+B{r\A$h4K]H)ڷ|1s y6+x)u3)ۛANkm$K~ny!.9P=ѴZwtw5\+RRF\%<Y/]܍Khg7.{p >ZWА}_YFBhWgE2L h9ېo[lŴഛrVK[#!VnJ"Ok% Z&C}ؼP g^)Vꦐ1GGk\L̡Vu&k:tR~ .L M#NRی|K bK蓞 4 { 0nJ܉r-.9/\1Etbށ7ɟgM1L){uI|X[Xdp}Q8g1i-2a _hg(Ɲ[Xp:Le#~ۚ;.4`7p2ޥ֒S鸂A.7Nb ԳXRү'-U5\Um@W48NB6W-e J.5\ֲ+Vڏ%ǰR&I= 8||S;8ݎJug๡~z8ٞnsoԯWu˾]cM̈#[23i֊FPShSMV4z` w+|Fa\d)#L<=1pbu@:AB6ߥ#|#0!,,;pusZP7CD˥&A@cŰ!ܝ64ι330#Xkc ŀÐ7~G@1npڕE$w+K[Е_$;n|w wM#cN:An$U>5dlLMއ-(@+u-yE !,wi3FU=ƒv`\{ <) Cֳ.Ow#?R&.G!۶mFm4 Y+ZzTW\؈w5pڡLcr=c.к[Ӣ91hnȉ6Gʴ0'jsllop+{:w wD < C6??"֪䖫+ 5F  \+ 2Z9 _.+C5 ÉI:ŅO>c:)>7\m7_+g4߯ڛ>)s'!ÊfO:]Śp 3RtpO )TxB{6ڕ|Ot>>}tm*.Q+#/_4O`I8|z1$G(h i[ꮹj%(^'[PcX nhٌQzHɥ(,j-.E"T@{rDyv|ʄ!_?6l>;n3> ̎A&ZU}!l=]ܨDncfOPamVe 2о&MOAP*X|j >[@p$cˆԙ?C]ilۂ8ւ]syW G9I:nZT{ǝ//;$=OB6ke7Q4x i1cIڅV&}F#F촛xis i_mHccl~ 1l6~g*+ N<3Fms+C/t]a]ѵoo@;o oo2Ȭm6螖h֡SlэxSntYш 8uu_5xFB8yos"O߅܁*n d-ͩDD*d{:z Bh߯lIFQm!;ÐjCm@1nyV%gnYDnixD$IVi(}͆[XTvE{]#C6VPI)=eD^Mo! gXk EwBQC GT'*~ZB<4vKFR8W%ݐw-`x5-Up?p ii^Ӧ^tvW;M[WWe w!s/{ey3<6V< kq3;\ G! d/ib0T%$ds_XQ |B] `P\rQǗ4hu_UI-̥<[ a\l#.,;:z[̋TU@6ߩO*#O<+Gz "y5t[X%$ijK2qǍ<)rǍ"~{7HDO@ǧ/0'u!;$ijCml9ZңWrkNעj-V :]@asԭjNAnyo3-AĎd^Cu#Q擣VE?ytjj1'lUA߱Z)}pk8^#m'P:ښR_|Ѯ?jݟhA<4T9nVv$N{c~ {} B$[΀i{1l/SF+t>ܭ~]k@[Mݥr"Ga+z%S*0] -3^sU`>| w:1ƌc,'W^mR, 026V4*t xrN= *0c{_@~ЉꚡFǧ4Z'^{~Ne@+߃Ef\0z.m g^?QẅS{t9ϜRI?kO;nT H5av0;wh/7T]~"W4ZnXCR'>wY)UTLgk3g_NVf[kl s[OkUޏfs_, @67O4%} 'U)~"<DǟC?1i5=$$cX5%G*9w"^8Fʠ@J7STyZKŮL^|XEp_tlůKEU{RdܖNJh?NDMlv@Ǟ:QSqۀ!DM|l>Dm>;S~aMޗ}71?DB~eʈ,A;Ul=kﹿ"GAJ;`!v#J%c%&:@T;В 𡯑"(@>CSwHJ\+VIieqO=2=0c[.*UC֫vu1 HH$O!o*Z&-~(NB6>Iq Ir}$1|vuT1a6HxOD? lYгsB+jYcLO:%421$o?u㨈$Bfj[WD>e4XWLBr @1cy$ j= چϾ~ (qO1zh绝}iYj%7p6LwP-з;$IU}簪$1vpwF?vY3TnRrbM[6 ?\G@鋷pUÒVd@#`Go+][ 񧠀5gp6xϜ-kes "D=sbT2? V$I"Nշxj8! Ai!1$XσeM7FG<ԶvS&fvpFYőo8< 6}̊Dvq|Sz>Pߍ3רUnp5m*ZdPܒ+Z@ѿDRm&DF7UCҝ_ ބd:OQ$zrP,AIWs> nI3_]8$kjb(SzV1$vl7`NcCl1B ^AW;#Νou$8p7hL؍V_ߕg+-Qז8 D"AKh亾lT,L_ P޷Tk(]ܨTMH W5vBFd-昮CEfz-Z% Zj,Q`]b{%OҮ7SLPA g@Z̊{-26{-bwxe% l:!ʢ`U-*B~ouJM&TJusٰd6 ylFq,,|š JCƪ5~^2]ۅH\1#ҧnWݴk U)K\G娌eEoīKp̔e/hv>Ӱ2KngZ rT↋Mj?2E7 yMn?I[l k-&{qd|[$-(Ё^|dz."j$4'ثlسB;\[R]+=>A{u3-KYe]}muv2_XXZm͈N#(W|(^ngٮ? .ǫ~? 1>~/tIma ބc9t Ά}<Ú=t. Q6O5vOW%Op8!SH|ʼm+,KYv~!F X'/Z^Ӕ'Ew+_iѪe_!/eЗymD VHgiEOA?Wor'IgA* Y`[]X6%8M`M sLWKK-~&?YMW:D=MvD~ n%N;zfH]ddOb&O}&|D1rg]3y*.jބ!zՖ-o/sӽLvxvx.15RORgMknG}4lQ +뼨0Gg@IG״k˕E/sͩ:R_|{e Xn:ڢ~ MxT1#56})uDx|(ӌ-4m:ɐހYARgLƞs#=|K:~@[KڦRu !'@I":0b7< Z'k. <i;0j@ z?|Ѭtp>-j$$>P[m(:iT+"$kZ[pCh8! \>TeO!Q%ÝVnV/znZX =^}Y5qc?_s'0̩Rfփ.( YAK͠D4Wk.Gp^Z=ӈn^hҍ?%$?7wZ PJ !⑫x?H z{6Nt7!ˡI?$Jwi͸̬WYs_Rҕ3vQ+[+ozR=vfQ bˆQ)dDSEw榮ÊFU֋/|LQbί|o-]0}ܓJnhnǺΚjU4U>8ʇƴ 3Bᳫ~>!ClwsGB &N.RUԓQ'nFTCpص")ƾɠoC_xt=zӧ;RҞ*&]QxKxvմ}OXh Į$r19F?QeM|D O>,ZgrQS{m%Εh-%Gwse[v0k~S;z6\,Nɮ4"2Zq{Kg ;9w9a a{g 8td0Amm$a#ЏLޏkKM\ޏ* 㠥ڔ#[8ēۋ' -4%nQF._.y{܂yV3⿮8^?s.I\͵FceMgV=b}ٰ+|+MYu5.V^ C <Q2FEɓ @_2ʪ$T kT}R_]}R:|Z}.+yx| Z]{>}Tb(3~S Q~pTּqP}Z9Ň8$kk8o렲d[:&of9n_wMnT1d9 d*< !$q_rdTAo߼ ,dm ZÌ(;8J;lVR%8ēnɴdKe] kAM,׵b BMGޤloNXaPֹR#k(Iz&ZbC<6u洪6?ɦd-ffZ6:AoЅuHg8ģ:O ;>č8xW6&Dj Mh=N<ɴus߷2j ZjGq-Q kjx%uו55F\ĸ|ZzȂԿׁh/YUeW K e2 V-UA̕IrPt;Dr⟀ZiQ}Ѭl٨6M'&qmO^ăDR$8SG %:eyR_9r{)gʱ\xU.f  |Z}t3؏Mۚ.0DxrbrVIJoasn phãԬZ]u @ifً?QNۘrπ[a?ݓg} D4 U0i؝:CvfN1|=,x} qA-/,&]b֗+U^ݬ sL"O=vtUQe7Zy6[ kئz\]TCYΔf@ৣk^ CU^-GofnAP .O~Hsg.s,SUر`tdṯYP(䂃-9$M~U+5K~ w4Q" 0q$aG =obnpb.>D\O+nja7ZHOOJZo60qcѨ%r|@{dAk|@vvT}ht3d=\tF Q+"ۓfEXN!+zrSn-~Vfj|`7cI(p&(>cCr<O|Z}Vs 8Գaa K14ʻ j*$aЇ7bxewެ͛R\̀Q&D dU)'_/UJK>ը13ybj ޟͼ_a *r3yTL2RLOsAr۠o>ބl$p"p VQ,p+J9^0]j^{n;z?/`ۀ@۔5uwu#nA&9ģ(F6#_06e8iU!* |JE&a@QTZXs@$0D)',Px"pjZnESn!Yh!vGAU05s 䀓')EH0΀IF''gAU5&6EV$wo IuzppZ{F԰+5îTWZ}BrAx2ZS2}5Xg͚n` J $ se";ELx);$IZ  FC%N!@[P#ch0@?F&và+h;f=ك$&C5[r&yƀ  vH*qc^K9ߝpe82 $)$9` t}B³YMsK~p;#I5﹁_xXmtg`b-ra?F?s2  Nς>Js%o)_G"37ezž)#<Zj@#A'AKt0fti/0D: Zgf45V,+` MR]E,oct02WHc@fb+(']=Bi1R@4vJU1~ 'vYǘQ* W8qxqm^mݟhtMҜ-N*Iyu1.Z<|\آi.k7#G!vc@bFJ}ܥZFsGS7Qu,ƃGcQ-\Dx&(VI;I"E!E/PT?%R"#䮳S3eFBbKbYQBnbF@²$V_ёܙlNJa*Lկ!s7̖=GP*#ַzCڲ{7 'aoW Q쌌EݧoK'~3^8Ԗ5Z.ͭ֘{ߛ43Z8KWJ\2pިVkVz,\G#ZƆmͅJ݌l/ 1ü[Aom.oY _| 4w >J ";wo첇0w=궫|5*oR7ve92Qϸ)XW.|1IѵL{l+%Eҍs6>,#dOFbꬹa,j]"tDx4hQ,/i5WT7Yp7 & }'yѤͶjtEQ C;@H@1PN;W !I 3 ؕFV2%ilx_jj>5[+EwAhUnŭ.dtZ5nJڪȊpGV)[1g6\,Nɮ4Hj$k\aP!d&TMz|ވPX^r]Z5CX֮LX-eKt  QO󑑰L\}ʡ܋q \Z?듣!C9l>/ĮMI 7Q9'ך7:+uxGf-Qe~v8{V|xxdz ʑŧ악曊:S0zi{_䦧Yןh)n.e.i{TqMJ#5\;v.u/syV2JK^/]_>Ζâ3L=+r 2H0hzcUMŠPMϣNKN#2b6F;x9hm0^ג422ZlZzWN渖l)LQE}[Y-v%7bY2mSx,;н=%%̮>BnZJs0Gqs?6j?@3e% 24Eo7[ GOA?x8zaM=UؚOwG/uzCx?p- r;}5k[=**ܚmpO ۢMY>DK;/wM6E T4k]*>Cl:~}8v8J 8zB[-:m{H'ٌ+4nvc^#tsy5eÿ\ۀA?VB Y,TpfxRvֿf~ p<#B-uzZ&UF?iUۢm5? @;G!>!V(+Wu=a5&FMŝq}L[S_mnڦ7]B" qG%Tš68Գz"166kFg2ycOLR %O4OƵ60؍>y޹q?}oKS/5PQ:s"| Z<ޝ_֟/ZtuNKNjSM?^<a?̅[s_6t xF@})TSdw7PMv_x3"zh-vovvJg4mj]p F$=`m~#E;1sU)n=o#쉒UD}8YCٲ7(s; qF>Nap*Πz|u /8guo4a{.a4al^u5N- q&jڥ 3H'jF LS=i9pU۫a٤Mҙ^"h˭HK\VӍ=v~FVBQ٠_5/[W_+i;M' ,c?-5Ux;2څKvb  "فGS׊؞Lkk 2 (K ~ 5mش&R~:u*R=h;H;}M*uZ]">F>XH};u}=;im{ud:ɝ(<i]n{v8oGTX++NZ,ǝ.M3%^d#,qN&Sǝ:gLL#ރw;"6cӺH`ty2Nv4wM;~5=n("yr^{*`XY0czcKV+-C^'QTИw=I7N^5! +Gw`1!}kQC2r.2uvK yMm|k%9!նpkoC]w Tz]h8쾼p`*m[=#֎W`]Lm34S R 8pul]gz=p \q`;I(^]*NUf7'-˃VM۬0(ƭ;`>ϹqAj0K:`ҴVU^8?hBm)?tK[=Y7_ZͨgȭXTTF\x O)\~%/_In}L^}I6VD4{L^S9p9T'r;ܒnԃdL%THjR9p[M21H)w췱&y2R9x9ڙjeg>n=ܜ5IM#T#i>x>ئdإl 6R vT)yyT)mc!<1Im#w8dCqfrA6̏GϾ/2Rz+݃`fuؕotVR0OZY(R;:d{lNr#uÔ%UHjg'U [GٓV9V|T1nL L_g\׺裨5%˜D$0''wڨ2k/k6ek5^Ƣ!YD$8p/l=N"b7 zvwDD}:y Fbn">xÿ$:%?LjMM|]_x+DYu#QƦ D!e2$szveʐJНZej*cY@fDaL252zjis7.q&54cUJt[ӧ}1 xE\lZp7('^xvt/wڨ'MƞY%e5ql鲺2Z3N*^W%6o^Np er}S%/ry:/C8aHCtQUřGBē*KNrlq|ӰhN:7rqE|R-0u|Sq\g*W-7, TZ&̠ic:ԭX\̒M;7(tbxGPʓ`pG)d*癖UIۓ8ݮh9<_¼.c_,B8Q'(c9͊kWWXviūS+-Qr6ZƪyF;DMQ5ۀ@?PVꆍU_YMU%>{p]DGi lb׮E͙Ĝ΀ߜÄ ς>9sIܜj[:2wޭͰu_:VWesOԬI}O@K L >mS65>S>Yb@B1 m|L]xΚ~u;bZ(p{;.[AX5=pbC<[!XX-|c{HB1vۥ|;>,D{A=#6Y(bIrؒ"}c)\٦۴l3668Gʒn;Fȭ{Y Z}Aq}& }#hcqRU]IU7 <5ciuwjFɶD|SA, NJsj$&R{ļ6-׎thZ]ݠFcb.1 {@K~@bCXYg7xSfalcjbƪ;QwY5c03hFM\^}I(Y^Į F}*x 襒NukY$CcZ܃Y._x,@2}=th PW>0c\7nZ^cy,OA!386r'ZC!!Qxb8\}nZԧDcnf3:5^tnklZQ>K>PY;y8Tlv$wIQv oa8]f sa)Г/\2řA~\mjRwMTSYM? Q㇒>}8{;pGfU=*♝$^$S;GAGJ+H)`ΉGr3'a{&o h" mYM !8%ע]4c,ާUo\M9e{, ggN^Zh4LCX#!yhd<2zcUn^̆G{Ae(R1=fT\iNȔf!=v*֦Hͪge4ӋE_%סߏ\>:cOyX5̼| +mGvJM7DW FP rѶ8!‚-fԓ+5vNG‡eVG71vHLPKO"T3b^pN4d&ay>:"d&v{A'؃^4Re H3 >hV,z9_y].s:fiZԼxUkp}fw9.%q PijR٨ʲ@]r!Ptl\ф\*M+UAT(BhJ0Vl۬ Ŝڼ卞 ާʅڊ#BS=p@ѵg= 0q)x~]w!uR𷜤3Jog~&ʙ(?y['8oV9OU xk!vQ*nT&^Nܨi8(9R$yssN1'*3 ]]a?Rb@Q"VςѪQr>@:9'67T\?h+%NPђ\-u*$FL@t y~ըӡÕ`°f ; 5_<-Zpt_ZUʦ4lk6 tn7{VП{Wk#,1ha3=.p +-Ml>ŠVki+8(zF[ #8ԓMX n}FȹIϯ^?qMtǾ:s*.65yөtْQ/Wb5pzG/\ (L Rc+[P7܅GI!E1ILrsȫɷc4w35..'+d+2jhP?zh⋮Ry^pz!SUֻBs43C.6ޏI~. *?$p"SUyp ;cmr$T#I\i?({E&Ävb-JUpnz߼ڬV'R~b}חM8Go4tZ_º|ZeTWLb%%KS-N6ZH P:~sM~;Ҵ9*Nxfm9&s-:W2$w2K܇ >CiPe1J)"I+\!o;ū=E`rK<"㭅z O{RQҬ-DI[CFKo^b5Yyf.զ+>n᙮dNm H!x~+=ҦDVt<_I=XRwC3BтPmrDT#|~b&!ِ",`V1;oBN,$[c{Rl~җ%:yi?yxN mReT&_q'qe_jUɮBAw*W离Ǩݕz_Bҡzgl*Fz{p yLVAJ^Y@ۄe5OM$y6jWW'Aw8ēCZUoE[obypr@_s'i1JPzAT2ChlۼḶU_|뇼W%Lׄb"Bu`6Cwr'qE-@9 Z;Ϝ ^/ 9?y.$n0EqCBa=vj$g8ē%|C)iKP(!w=iI\(Uw>P=EXՙ2e[2 VO#XbC9^W%?\\τmy}^F|ɨS 7QMhc>LA ڮI[Ǡ#s֥z:?BðcaNB"@绂 Âb;QW{"r EN\}[QEI]}G9 L waF (۳͒g=+RN`QNJj`>x$d: ̃w{pj1kx&myڻ[)Ad5WXÌ-&7:w]|pS\$%6%jZ Sj\'F Itxt]ExQ8 v&B亡X6]Ruzp> n gzc31oXRH!H6QUqhErxMeydF1ǥ#Q.r?CsEFBP mg`8D\^}=p؝-:g_r pxmeA)ei(W@zʶ"Ea1$<FV"؎>HFn f~\u;K2jc}6vQ:b?ġ|$k@ѫxdZb=+T7^Y˂\@K]ѓhhKx +O▕KZGVxQxtJӾ}nR&%|rqt| iwVrOuzwKͰP Q ˦S+ |PUz#Fä~ph.<-;K.n-DglBJgrP}u(64%׺H8?"Vd>ʦQuIsbAƿ !1pkTc8O-,Zu84k5îx5$ԛyFL0%<[h{ʴ~)enntǩT됑p'{t[\ i HHx>4CȎxccQϧKoA2#RU 'e[j!atN}\ÝjIo\3S` ߅S'å!+Z[HqgB$S.3n`F]kˆ]f̕ז]L_ta'_>?w+EXc^ o|uQ$eeU ɪ\1]/^Wꇰjݳ%(߄A6"8'yѤ?<%n-5'_7ޜB8x*`[-t };qp XeM!VKs}ƭ5ff*Οxҕ'G;fjF};rZk[;ozV|`9\-[/m_ :A lqr׭ fW=IǏ>p*/i{?Qz2.?ֹƽݰͲP[1^-1 Rdpack/tests/0000755000175000017500000000000014044254045012754 5ustar nileshnileshRdpack/tests/testthat/0000755000175000017500000000000014204025772014615 5ustar nileshnileshRdpack/tests/testthat/myshow-methods.Rd0000644000175000017500000000065614200040646020073 0ustar nileshnilesh\name{myshow-methods} \docType{methods} \alias{myshow-methods} \alias{myshow,ANY-method} \alias{myshow,Seq-method} \title{~~ Dummy title ~~} \description{~~ Dummy description ~~} \section{Methods}{ \describe{ \item{\code{signature(object = "ANY")}}{ %% ~~describe this method here~~ } \item{\code{signature(object = "Seq")}}{ %% ~~describe this method here~~ } }} \keyword{methods} \keyword{ ~~ other possible keyword(s) ~~ } Rdpack/tests/testthat/as.character.f_usage.Rd0000644000175000017500000000267714200040646021057 0ustar nileshnilesh\name{as.character.f_usage} \alias{as.character.f_usage} %- Also NEED an '\alias' for EACH other topic documented here. \title{~~ Dummy title ~~} \description{~~ Dummy description ~~} \usage{ as.character.f_usage(x, ...) } %- maybe also 'usage' for other objects documented here. \arguments{ \item{x}{ %% ~~Describe \code{x} here~~ } \item{\dots}{ %% ~~Describe \code{\dots} here~~ } } \details{ %% ~~ If necessary, more details than the description above ~~ } \value{ %% ~Describe the value returned %% If it is a LIST, use %% \item{comp1 }{Description of 'comp1'} %% \item{comp2 }{Description of 'comp2'} %% ... } \references{ %% ~put references to the literature/web site here ~ } \author{ %% ~~who you are~~ } \note{ %% ~~further notes~~ } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ %% ~~objects to See Also as \code{\link{help}}, ~~~ } \examples{ ##---- Should be DIRECTLY executable !! ---- ##-- ==> Define data, use random, ##-- or do help(data=index) for the standard data sets. ## The function is currently defined as function (x, ...) { deparse_usage1(x) } } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory (show via RShowDoc("KEYWORDS")): % \keyword{ ~kwd1 } % \keyword{ ~kwd2 } % Use only one keyword per line. % For non-standard keywords, use \concept instead of \keyword: % \concept{ ~cpt1 } % \concept{ ~cpt2 } % Use only one concept per line. Rdpack/tests/testthat/char2Rdpiece_b.RDS0000644000175000017500000000015613501141722017756 0ustar nileshnileshb```b`fed`b1#, @Z4'?]BG!)8UV!@PS I[PJ|Ib:5QM[Liqbz*HRdpack/tests/testthat/test-bib.R0000644000175000017500000001015414177674664016475 0ustar nileshnileshcontext("bib") test_that("bib works fine", { fn_Rdpack <- system.file("REFERENCES.bib", package = "Rdpack") bibs_Rdpack <- if(packageVersion("rbibutils") >= '2.1.1') readBib(fn_Rdpack) else readBib(fn_Rdpack, encoding = "UTF-8") fn_rb <- system.file("REFERENCES.bib", package = "rbibutils") bibs_rb <- if(packageVersion("rbibutils") >= '2.1.1') readBib(fn_rb) else readBib(fn_rb, encoding = "UTF-8") .toRd_styled(bibs_rb, "Rdpack") .toRd_styled(bibs_rb[["Rpackage:Rdpack"]], "Rdpack") .toRd_styled(bibs_rb[["Rpackage:Rdpack"]], "rbibutils", style = "JSSRd") set_Rdpack_bibstyle("JSSRd") set_Rdpack_bibstyle("JSSLongNames") ## parenthesised expect_equal(insert_citeOnly("Rpackage:Rdpack", package = "rbibutils"), "(Boshnakov 2020)") expect_equal(insert_citeOnly("Rpackage:Rdpack;nobrackets", package = "rbibutils"), "Boshnakov 2020") ## using @ expect_equal(insert_citeOnly("@see also @Rpackage:Rdpack", package = "rbibutils"), "(see also Boshnakov 2020)") expect_equal(insert_citeOnly("@see also @Rpackage:Rdpack;nobrackets", package = "rbibutils"), "see also Boshnakov 2020") expect_equal(insert_citeOnly("@see also @Rpackage:Rdpack among others;nobrackets", package = "rbibutils"), "see also Boshnakov 2020 among others") ## textual expect_equal(insert_citeOnly("Rpackage:Rdpack;textual", package = "rbibutils"), "Boshnakov (2020)") expect_equal(insert_citeOnly("@@Rpackage:Rdpack;textual", package = "rbibutils"), "Boshnakov (2020)") ## more than one key expect_equal(insert_citeOnly( "@see also @Rpackage:rbibutils and @parseRd;textual", package = "Rdpack"), "see also Boshnakov and Putman (2020) and Murdoch (2010)") ## commenting out since not sure if the ')' is on purpose after "among others" (:TODO:) ## ## expect_equal(insert_citeOnly("@see also @Rpackage:rbibutils and @parseRd, among others;textual", package = "Rdpack"), ## "see also Boshnakov and Putman (2020) and Murdoch (2010, among others)") expect_equal(insert_citeOnly( "@see also @Rpackage:rbibutils and @parseRd", package = "Rdpack"), "(see also Boshnakov and Putman 2020 and Murdoch 2010)") expect_equal(insert_citeOnly( "@see also @Rpackage:rbibutils and @parseRd;nobrackets", package = "Rdpack"), "see also Boshnakov and Putman 2020 and Murdoch 2010") expect_equal(insert_citeOnly( "@see also @Rpackage:rbibutils and @parseRd;nobrackets", package = "Rdpack"), "see also Boshnakov and Putman 2020 and Murdoch 2010") ## use brackets instead of parentheses expect_equal(insert_citeOnly("Rpackage:Rdpack;textual", package = "rbibutils", bibpunct = c("[", "]")), "Boshnakov [2020]") expect_equal(insert_citeOnly("Rpackage:Rdpack", package = "rbibutils", bibpunct = c("[", "]")), "[Boshnakov 2020]") insert_ref("Rpackage:Rdpack", package = "rbibutils") ## missing keys expect_warning(insert_ref("xxx", package = "rbibutils")) expect_warning(insert_citeOnly( "@see also @Rpackage:rbibutils and @parseRd;nobrackets @kikiriki", package = "Rdpack")) ## "possibly non-existing or duplicated key(s) in bib file from package ..." ## TODO: this tries to load package "xxx" and gives error but finishes ok and returns a ## dummy reference, as expected. ## ## Why and which instruction tries to load package "yyy"? Maybe in .Rd_styled? ## It is sufficient that the package is installed, it doesn't need to be loadable. ## expect_warning(insert_ref("xxx", package = "yyy")) # missing package expect_warning(insert_ref("xxx", package = "yyy")) insert_all_ref(matrix(c("parseRd,Rpack:bibtex", "Rdpack"), ncol = 2)) class(bibs_rb) <- c("bibentryRd", class(bibs_rb)) expect_output(print(bibs_rb)) ## makeVignetteReference("Rdpack", 1) }) Rdpack/tests/testthat/get_sig_text_f1.RDS0000644000175000017500000000010213501141722020224 0ustar nileshnileshb```b`fed`b2Hg%jT(*(9E*iA2Rdpack/tests/testthat/char2Rdpiece_c.RDS0000644000175000017500000000016713501141722017761 0ustar nileshnileshb```b`fed`b1|d iN ؂RKӁ,T!@3RrRR+s rR 3mVy<iRdpack/tests/testthat/StructureClasses.Rd0000644000175000017500000001722414200040646020421 0ustar nileshnilesh\name{StructureClasses} \alias{structure-class} \alias{matrix-class} \alias{array-class} \alias{ts-class} \alias{Math,structure-method} \alias{Ops,structure,vector-method} \alias{Ops,structure,structure-method} \alias{Ops,structure,array-method} \alias{Ops,vector,structure-method} \alias{Ops,array,structure-method} \alias{Ops,array,array-method} \alias{initialize,array-method} \alias{initialize,matrix-method} \alias{initialize,ts-method} \alias{initialize,mts-method} \alias{show,ts-method} \alias{matrix} \alias{array} \alias{ts} \alias{structure} \title{Classes Corresponding to Basic Structures} \description{ The virtual class \code{structure} and classes that extend it are formal classes analogous to S language structures such as arrays and time-series. } \usage{ data matrix nrow matrix ncol matrix byrow matrix dimnames data array dim array dimnames data ts start ts end ts frequency ts deltat ts ts.eps ts class ts names .Data structure ... } \arguments{ \item{data}{~~ TODO: describe this argument. ~~} \item{nrow}{~~ TODO: describe this argument. ~~} \item{ncol}{~~ TODO: describe this argument. ~~} \item{byrow}{~~ TODO: describe this argument. ~~} \item{dimnames}{~~ TODO: describe this argument. ~~} \item{dim}{~~ TODO: describe this argument. ~~} \item{start}{~~ TODO: describe this argument. ~~} \item{end}{~~ TODO: describe this argument. ~~} \item{frequency}{~~ TODO: describe this argument. ~~} \item{deltat}{~~ TODO: describe this argument. ~~} \item{ts.eps}{~~ TODO: describe this argument. ~~} \item{class}{~~ TODO: describe this argument. ~~} \item{names}{~~ TODO: describe this argument. ~~} \item{.Data}{~~ TODO: describe this argument. ~~} \item{...}{~~ TODO: describe this argument. ~~} } \references{ Chambers, John M. (2008) \emph{Software for Data Analysis: Programming with R} Springer. (For the R version.) Chambers, John M. (1998) \emph{Programming with Data} Springer (For the original S4 version.) Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) \emph{The New S Language}. Wadsworth & Brooks/Cole (for the original vector structures). } \section{Objects from the Classes}{ Objects can be created by calls of the form \code{new(Class, ...)}, where \code{Class} is the quoted name of the specific class (e.g., \code{"matrix"}), and the other arguments, if any, are interpreted as arguments to the corresponding function, e.g., to function \code{matrix()}. There is no particular advantage over calling those functions directly, unless you are writing software designed to work for multiple classes, perhaps with the class name and the arguments passed in. Objects created from the classes \code{"matrix"} and \code{"array"} are unusual, to put it mildly, and have been for some time. Although they may appear to be objects from these classes, they do not have the internal structure of either an S3 or S4 class object. In particular, they have no \code{"class"} attribute and are not recognized as objects with classes (that is, both \code{\link{is.object}} and \code{\link{isS4}} will return \code{FALSE} for such objects). However, methods (both S4 and S3) can be defined for these pseudo-classes and new classes (both S4 and S3) can inherit from them. That the objects still behave as if they came from the corresponding class (most of the time, anyway) results from special code recognizing such objects being built into the base code of \R. For most purposes, treating the classes in the usual way will work, fortunately. One consequence of the special treatment is that these two classes\emph{may} be used as the data part of an S4 class; for example, you can get away with \code{contains = "matrix"} in a call to \code{\link{setGeneric}} to create an S4 class that is a subclass of \code{"matrix"}. There is no guarantee that everything will work perfectly, but a number of classes have been written in this form successfully. Note that a class containing \code{"matrix"} or \code{"array"} will have a \code{.Data} slot with that class. This is the only use of \code{.Data} other than as a pseudo-class indicating the type of the object. In this case the type of the object will be the type of the contained matrix or array. See \code{\link{Classes_Details}} for a general discussion. The class \code{"ts"} is basically an S3 class that has been registered with S4, using the \code{\link{setOldClass}} mechanism. Versions of \R through 2.7.0 treated this class as a pure S4 class, which was in principal a good idea, but in practice did not allow subclasses to be defined and had other intrinsic problems. (For example, setting the \code{"tsp"} parameters as a slot often fails because the built-in implementation does not allow the slot to be temporarily inconsistent with the length of the data. Also, the S4 class prevented the correct specification of the S3 inheritance for class \code{"mts"}.) Time-series objects, in contrast to matrices and arrays, have a valid S3 class, \code{"ts"}, registered using an S4-style definition (see the documentation for \code{\link{setOldClass}} in the examples section for an abbreviated listing of how this is done). The S3 inheritance of \code{"mts"} in package \pkg{stats} is also registered. These classes, as well as \code{"matrix"} and \code{"array"} should be valid in most examples as superclasses for new S4 class definitions. All of these classes have special S4 methods for \code{\link{initialize}} that accept the same arguments as the basic generator functions, \code{\link{matrix}}, \code{\link{array}}, and \code{\link{ts}}, in so far as possible. The limitation is that a class that has more than one non-virtual superclass must accept objects from that superclass in the call to \code{\link{new}}; therefore, a such a class (what is called a \dQuote{mixin} in some languages) uses the default method for \code{\link{initialize}}, with no special arguments. } \section{Extends}{ The specific classes all extend class \code{"structure"}, directly, and class \code{"vector"}, by class \code{"structure"}. } \section{Methods}{ \describe{ \item{coerce}{Methods are defined to coerce arbitrary objects to these classes, by calling the corresponding basic function, for example, \code{as(x, "matrix")} calls \code{as.matrix(x)}. If \code{strict = TRUE} in the call to \code{as()}, the method goes on to delete all other slots and attributes other than the \code{dim} and \code{dimnames}. } \item{Ops}{Group methods (see, e.g., \code{\link{S4groupGeneric}}) are defined for combinations of structures and vectors (including special cases for array and matrix), implementing the concept of vector structures as in the reference. Essentially, structures combined with vectors retain the structure as long as the resulting object has the same length. Structures combined with other structures remove the structure, since there is no automatic way to determine what should happen to the slots defining the structure. Note that these methods will be activated when a package is loaded containing a class that inherits from any of the structure classes or class \code{"vector"}. } } } \seealso{Class \linkS4class{nonStructure}, which enforces the alternative model, in which all slots are dropped if any math transformation or operation is applied to an object from a class extending one of the basic classes. } \examples{ showClass("structure") ## explore a bit : showClass("ts") (ts0 <- new("ts")) str(ts0) showMethods("Ops") # six methods from these classes, but maybe many more } \keyword{classes}Rdpack/tests/testthat/char2Rdpiece_a.RDS0000644000175000017500000000014213501141722017750 0ustar nileshnileshb```b`fed`b1#, @#( #3 I-(%$1BVAT3GN,/J{ƀRdpack/tests/testthat/test-reprompt.R0000644000175000017500000001147714200040301017554 0ustar nileshnileshcontext("reprompt") test_that("reprompt works fine", { tmpfn <- tempfile(fileext = rep(".Rd", 4)) on.exit(unlink(tmpfn)) reprompt("viewRd", filename = tmpfn[1]) reprompt(infile = tmpfn[1], filename = tmpfn[2]) fn1 <- system.file("examples/reprompt.Rd", package = "Rdpack") reprompt(fn1, filename = tmpfn[2]) ## contains S3 method as.character.f_usage reprompt(as.character.f_usage) ## S4 ## from package "methods" - this page is peculiar; eg has no section 'arguments' reprompt("ts", type = "class") reprompt("show", type = "methods", package = "methods") ## (TODO: investigate) Need 'expect_warning' here since the following warning is issued ## for the S4 reprompt's: ## Calling 'structure(NULL, *)' is deprecated, as NULL cannot have attributes. ## Consider 'structure(list(), *)' instead. ## Backtrace: ## 1. Rdpack::reprompt("initialize", type = "methods", package = "methods") test-reprompt.R:20:4 ## 2. Rdpack::inspect_Rd(rdo, package = package) /home/georgi/repos/private/Rdpack/R/repromptAny.R:65:8 ## 3. Rdpack::inspect_Rdfun(rdo) /home/georgi/repos/private/Rdpack/R/inspect.R:60:4 ## 4. Rdpack::inspect_usage(rdo) /home/georgi/repos/private/Rdpack/R/inspect.R:148:4 ## 5. Rdpack::get_usage_text(rdo) /home/georgi/repos/private/Rdpack/R/usage.R:2:4 ## 6. base::structure(rdo_u, Rd_tag = "Rd") /home/georgi/repos/private/Rdpack/R/manip.R:260:4 expect_warning(reprompt("initialize", type = "methods", package = "methods")) expect_warning(reprompt("classRepresentation", type = "class")) setClass("Seq", slots = c(from = "numeric", to = "numeric", by = "numeric")) setMethod("show", "Seq", function(object){ print(c(from = object@from, to = object@to, by = object@by)) }) ## this doesn't include "Seq" - TODO: investigate reprompt("show-methods", filename = tmpfn[2]) ## myshow <- function(object) NULL # this doesn't work here TODO: why? setGeneric("myshow", function(object) NULL) setMethod("myshow", "Seq", function(object){ print(c(from = object@from, to = object@to, by = object@by)) }) reprompt(myshow, type = "methods") ## this doesn't work in R CMD check: ## reprompt("Seq", type = "class", filename = tmpfn[2]) ## adapted reprompt.Rd tmpdir <- tempdir() old_wd <- setwd(tmpdir) on.exit({setwd(old_wd); unlink(tmpdir)}, add = TRUE) ## as for prompt() the default is to save in current dir as "seq.Rd". ## the argument here is a function, reprompt finds its doc and ## updates all objects described along with `seq'. ## (In this case there is nothing to update, we have not changed `seq'.) fnseq <- reprompt(seq) ## let's parse the saved Rd file (the filename is returned by reprompt) rdoseq <- tools::parse_Rd(fnseq) # parse fnseq to see the result. Rdo_show(rdoseq) ## we replace usage statements with wrong ones for illustration. ## (note there is an S3 method along with the functions) dummy_usage <- char2Rdpiece(paste("seq()", "\\\\method{seq}{default}()", "seq.int()", "seq_along()", "seq_len()", sep="\n"), "usage") rdoseq_dummy <- Rdo_replace_section(rdoseq, dummy_usage) Rdo_show(rdoseq_dummy) # usage statements are wrong ## TODO: this works in the examples but fails devtools::test() ## reprompt(rdoseq_dummy, filename = "seqA.Rd") ## Rdo_show(tools::parse_Rd("seqA.Rd")) # usage ok after reprompt ## define function myseq() myseq <- function(from, to, x){ if(to < 0) { seq(from = from, to = length(x) + to) } else seq(from, to) } reprompt(myseq, filename = "tmp.Rd") ## we wish to describe myseq() along with seq(); ## it is sufficient to put myseq() in the usage section ## and let reprompt() do the rest rdo2 <- Rdo_modify_simple(rdoseq, "myseq()", "usage") reprompt(rdo2, file = "seqB.Rd") # updates usage of myseq ## show the rendered result: Rdo_show(tools::parse_Rd("seqB.Rd")) ## Run this if you wish to see the Rd file: ## file.show("seqB.Rd") reprompt(infile = "seq.Rd", filename = "seq2.Rd") reprompt(infile = "seq2.Rd", filename = "seq3.Rd") ## Rd objects for installed help may need some tidying for human editing. #hseq_inst <- help("seq") #rdo <- utils:::.getHelpFile(hseq_inst) rdo <- Rdo_fetch("seq", "base") rdo rdo <- Rdpack:::.Rd_tidy(rdo) # tidy up (e.g. insert new lines # for human readers) reprompt(rdo) # rdo and rdoseq are equivalent all.equal(reprompt(rdo), reprompt(rdoseq)) # TRUE }) Rdpack/tests/testthat/get_sig_text_f4.RDS0000644000175000017500000000015213501141722020234 0ustar nileshnileshb```b`fed`b2Hg%jT(*(9E*(T˜PehR aJ\"e&TDr0) attr(res, "Rd_tag") <- rdtags[[ indx[1] ]] } res } Rdpack/R/Rdo2Rdf.R0000644000175000017500000002442113501141722013375 0ustar nileshnilesh # backslashes need to be escaped before braces # otherwise backslahes in \{ and \} may get escaped. .bs2 <- function(x) gsub("([\\]+)", "\\1\\1", x) # escape backslash (bs) .esc_br <- function(x) gsub("([{}])", "\\\\\\1", x) # escape {, } .bspercent <- function(x) gsub('([^\\%]?([\\][\\])*)%', '\\1\\\\%', x) # escape percents .anypercent <- function(x){ tag <- attr(x, "Rd_tag") if(is.null(tag) || tag != "COMMENT" ) .bspercent(x) # expects, correctly that `tag' does not disappear else # but see the comment above about usage with Rdapply. x } # this seems incomplete, since \v and \l should be doubled only in R strings when # in RCODE but in contexts where parse_Rd considers them (and other # escaped sequences) to be markup macros, they will be in the Rd_tag # attribute, not in the string. So, it seems that more complicated # processing is not needed. # 2012-10-14 dobavyam obrabotka na poveche ot edna cherta. Togava vsichki osven # poslednata tryabva da se udvoyat (may), a poslednata se udvoyava ako e # posledvana ot v, l ili kray na string. .escape_bs_in_Rcode <- function(rdo){ f <- function(x) if(grepl("\\\\", x)){ # if x contains any backslashes # before 2012-10-14: gsub("(\\\\+)(v|l)", "\\1\\1\\2", x) res <- x res <- gsub("(\\\\+)(\\\\)", "\\1\\1\\2", res) res <- gsub("(\\\\)(v|l)", "\\1\\1\\2", res) res <- gsub("(\\\\)$", "\\1\\1", res) res <- gsub("(\\\\)('|`|\")", "\\1\\1\\2", res) # browser() res }else x Rdtagapply(rdo, f, "RCODE") } # 2012-09-29 included srcref processing # todo: this function was patched many times, needs rewrite Rdo2Rdf <- function(rdo, deparse = FALSE, ex_restore = FALSE, file = NULL, rcode = TRUE, srcfile = NULL){ if(is.character(rdo)) # otherwise print(rdo) may go into infinite recursion rdo <- list(rdo) if(class(rdo) != "Rd") # to force using print.Rd() class(rdo) <- "Rd" if(is.character(srcfile)){ # remember which sections have not changed rdoorig <- permissive_parse_Rd(srcfile) unchanged_sec <- .rdo_equal_sections(rdo, rdoorig) } # browser() if(rcode){ rdo <- .escape_bs_in_Rcode(rdo) # this also does the examples }else if(ex_restore){ # 2012-09-27 promenyam da izpolzva .escape_bs_in_Rcode # There should be no more than one `examples' section in a proper Rd object # and no `NULL' Rd_tag's at the top level. Allow them here since `rdo' may # be an `Rd' piece, not a whole Rd object or fragment. In this way this # function can be used for intermediate transformations. Note though that # print.Rd used below to produce the text output may be more picky. indx <- Rdo_which_tag_eq(rdo, "\\examples") for(i in seq_along(indx)){ if(!is.null(indx[[i]])) rdo[[ indx[[i]] ]] <- .escape_bs_in_Rcode(rdo[[ indx[[i]] ]]) } } rdo <- Rdtagapply(rdo, .esc_br, "nonmathVERB") # escape \{, \} rdo <- Rdtagapply(rdo, .anypercent, "nonmath") # escape % # 2012-10-14 # rdo<-Rdtagapply(rdo, function(x) gsub("((^|[^\\])([\\][\\])*)[\\]$", "\\1\\\\\\\\", x), # "VERB") rdo <- Rdtagapply(rdo, function(x) gsub("(^|[^\\])(\\\\+)$", "\\1\\2\\2", x), "VERB") # pos_only = function(x){ res <- 1; browser(); res } pos_filecmd <- Rdo_locate(rdo, function(x) .tag_eq(x,"\\file"), lists = TRUE) for(pos in pos_filecmd) rdo[[pos]] <- Rdtagapply(rdo[[pos]], function(x) gsub("(\\\\)", "\\1\\1", x), "TEXT") # pos_filecmd <- Rdo_locate(rdo, function(x) .tag_eq(x,"\\samp"), lists = TRUE) # for(pos in pos_filecmd) # rdo[[pos]] <- Rdtagapply(rdo[[pos]], # function(x) gsub("(\\\\+)([^\\])", "\\1\\1\\2", x), # "VERB") # krapka, za nesta kato \code{\\} (see in base R: basename.Rd, body.Rd, Arithmetic.Rd) # 2012-10-14 promenyam tozi (cautious) variant, koyto samo udvoyava edna cherta # kogato sa necheten broy s variant koyto udvoyava vsichki v kraya na \code{} string. # todo: da ne go pravi v examples section (no tam to trudno ste se sluchi) # rdo <- Rdtagapply(rdo, function(x) gsub("((^|[^\\])([\\][\\])*)[\\]$", # "\\1\\\\\\\\", x), "RCODE") # 2012-10-14 otkomentiram, promenich v escape_bs po-gore. # rdo <- Rdtagapply(rdo, function(x) gsub("([\\]+)$", "\\1\\1", x), "RCODE") if(is.character(srcfile)){ # replace unchanged sections with dummy contents unchanged_titles <- sapply(unchanged_sec, function(x) x$title) rdo <- .replace_dummy(rdo, unchanged_titles) } # this was used for saving before introducing tfn, etc. # res <- capture.output(print(rdo, deparse = deparse), file = file) # as.character.Rd ima bug svarzana s newcommand i/ili argumentite # na href, vzh. naprimer which.min.Rd v base, tam as.character dava # \href{{http://CRAN.R-project.org/package=nnet}{\pkg{nnet}}} # (nay-vanshnite skobi {} sa izlishni). todo: tova e krapka! rdotxt <- paste0(as.character(rdo, deparse = deparse), collapse="") rdotxt <- gsub("\\\\href\\{(\\{[^{}]*\\}\\{[^}]*\\}+)\\}", "\\\\href\\1", rdotxt) # todo: krapka; \code{\{} becomes \code{{} which wrecks havoc for parse_Rd; \code{\}} rdotxt <- gsub("(\\\\code\\{)(\\{|\\})(\\})", "\\1\\\\\\2\\3", rdotxt) tfn <- tempfile() # use a temporary file in case file and srcfile are the same on.exit(unlink(tfn)) if(is.character(srcfile)){ # 2018-02-07 removed the following, since redundant (see above): # tfn <- tempfile() # 2018-02-07 (removed the assignment) was: # res <- capture.output(cat(rdotxt, sep = "", collapse = ""), # file = tfn)# writes to tfn # but res is re-assigned below without being used. # Also, dropping capture.output() and moving 'file =' to cat() cat(rdotxt, sep = "", collapse = "", file = tfn) rdocur <- permissive_parse_Rd(tfn) # to set srcref srcrefpos <- .srcrefpos(rdocur, rdoorig, unchanged_sec) rdotxt <- rdo_text_restore(rdocur, rdoorig, srcrefpos, file = tfn) nc_ind <- Rdo_which_tag_in(rdoorig, c("\\newcommand", "\\renewcommand")) if(length(nc_ind) > 0){ nclines <- sapply(nc_ind, function(x) as.character(attr(rdoorig[[x]],"srcref"))) rdotxt <- c(nclines, rdotxt) # put before anything else todo: could try to put at } # original place or at least after any comments? writeLines(rdotxt, tfn) #overwrites tfn res <- if(is.null(file)) paste0(rdotxt, collapse = "\n") else{ file.copy(tfn, file, overwrite = TRUE) # todo: check success NULL # for clarity; capture.output above set it to NULL as tfn is not NULL } }else ## 2012-10-14 res <- capture.output(cat(rdotxt, sep = "", collapse = ""), file = file) ## 2018-02-07 was: ## res <- capture.output(cat(rdotxt, sep = "", collapse = "", file = file)) ## restoring the syntax from 2012, since it works also in the case file = NULL; ## res <- capture.output(cat(rdotxt, sep = "", collapse = ""), file = file) if(is.null(file)) res else{ cat("\tThe Rd content was written to file ", file, "\n") invisible(res) # res is NULL here } } .tmp_pos <- function(name, pos_list){ for(elem in pos_list) if(elem$title == name) return(elem$pos) NULL } .rdo_srcref <- function(rdo, tag){ # todo: special cases! pos <- Rdo_which_tag_eq(rdo, tag) attr(rdo[[ pos[1] ]], "srcref") } .rdo_replace_at <- function(text, pospair){ newtext <- as.character(pospair[[2]]) m <- length(pospair[[1]]) beg_line <- pospair[[1]][1] beg_col <- if(m > 4) pospair[[1]][5] else pospair[[1]][2] end_line <- pospair[[1]][3] end_col <- if(m > 4) pospair[[1]][6] else pospair[[1]][4] res <- c(text[seq_len(beg_line - 1)], if(beg_col > 1) paste0(substr(text[beg_line], 1, beg_col - 1), newtext[1]) else newtext[1], newtext[-1] ) le <- nchar(text[end_line]) # 2012-10-13 was: length(text[end_line]) (!?) if(end_col < le) res[length(res)] <- paste0(res[length(res)], substr(text[end_line], end_col + 1, le)) c(res, text[-(1:end_line)]) } # 2012-10-13 dobavyam 'ends' po-dolu, sluchva se sections da ne zapochvat na nov red! # vzh. NumericConstants.Rd v base ( stava: \note{dummy} \seealso{dummy} ) rdo_text_restore <- function(cur, orig, pos_list, file){ res <- readLines(file) if(length(pos_list) == 1){ res <- .rdo_replace_at(res, pos_list[[1]]) }else{ starts <- sapply(pos_list, function(x) x[[1]][[1]]) ends <- sapply(pos_list, function(x) if(length(x[[1]]) > 4) x[[1]][5] else x[[1]][2] ) p <- order(starts, ends, decreasing = TRUE) dec_pos_list <- pos_list[p] for(pos in dec_pos_list) res <- .rdo_replace_at(res, pos) } res } .without_duplicates <- function(x){ x[!(x %in% unique(x[duplicated(x)]))] } Rdpack/R/slots.R0000644000175000017500000000423013501141722013273 0ustar nileshnileshinspect_slots <- function(rdo, final=TRUE){ fullname <- .get.name_content(rdo)$name # name of the class with '-class' suffix cur <- .capture_promptAny(fullname, final=final) ## 2018-08-27 - non-exiting class (TDO: check if it could be something else here if(inherits(cur, "try-error")){ return(cur) } curnames <- .get_top_labels(cur, "Slots") # current slots rdonames <- .get_top_labels(rdo, "Slots") # slots in rdo icmp <- .asym_compare(rdonames, curnames) # compare; get fields $i_new, $i_rem, $i_com if(length(icmp$i_new)>0){ ## 2014-06-18 the labels contain Rd markup, as in \code{mo.col}, but this seems ## harmless. ## 2014-06-21 new slots were not handled correctly, see the changes below; ## see also inspect_clmethods - there is a lot of common ground. ## todo: consolidate? ## 2019-05-12 was: newnames <- names(icmp$i_new) # 2014-06-21 new newnames <- curnames[icmp$i_new] cat("Undocumented slots:", newnames # 2014-06-21 was: names(icmp$i_new) # 2014-06-18 was: icmp$i_new , "\n") cat("\tAdding items for them.\n") # todo: insert in particular order? cnt_newslots <- .get_top_items(cur, "Slots", newnames) # 2014-06-21 was: icmp$i_new cnt_newslots <- .nl_and_indent(cnt_newslots) # 2014-06-21 new # this ensures that the closing brace for "describe" # is on new line. todo: this needs to be indented. cnt_newslots <- c(cnt_newslots, list(Rdo_newline())) # 2014-06-21 new dindx <- .locate_top_tag(rdo, "Slots") rdo <- append_to_Rd_list(rdo, cnt_newslots, dindx) } if(length(icmp$i_removed)>0){ # todo: maybe put this note in a section in rdo? ## 2019-05-12 was: cat("Slots:", icmp$i_removed, "\n") cat("Slots:", rdonames[icmp$i_removed], "\n") cat("are no longer present. Please remove their descriptions manually.\n") } rdo } Rdpack/R/f_usage.R0000644000175000017500000001434013501141722013543 0ustar nileshnileshparse_pairlist <- function(x){ is.missing.arg <- function(arg) typeof(arg) == "symbol" && deparse(arg) == "" # x == NULL corresponds to functions with no arguments (also # length(NULL) is 0) also, NULL is a pairlist with length 0. # Is this function used with x other than pairlist? if(is.null(x) || length(x) == 0) # If not, the test of length(x) is redundant. return(list(argnames = character(0), defaults = character(0))) nonmis <- x[ !sapply(x, is.missing.arg) ] wrk <- character(length(nonmis)) names(wrk) <- names(nonmis) for(s in names(nonmis)){ wrk[[s]] <- paste(deparse(nonmis[[s]], backtick = TRUE, width.cutoff = 500L) , collapse = "\n") } list(argnames = names(x), defaults = wrk ) } # 2012-10-03 new arg. infix pairlist2f_usage1 <- function(x, name, S3class = "", S4sig = "", infix = FALSE, fu = TRUE){ structure(c(list(name=name, S3class=S3class, S4sig=S4sig, infix=infix, fu = fu), parse_pairlist(x)), class="f_usage") } print.f_usage <- function(x, ...){ tab <- max(nchar(names(x))) for(nam in names(x)){ if(is.null(nam)) next if(nam != "defaults") cat(nam, strrep(" ", tab - nchar(nam)), "=", x[[nam]], "\n") else{ defnams <- names(x$defaults) for(i in seq_along(defnams)){ if(i == 1) cat(nam, strrep(" ", tab - nchar(nam[i])), ":", defnams[i], "=", x$defaults[i], "\n") else cat(strrep(" ", tab + 3), defnams[i] , "=", x$defaults[i], "\n") } } } cat("\n") } format_funusage <- function(x, name = "", width = 72, realname){ res <- paste(name, "(", paste(x, collapse = ", "), ")", sep="") if(is.numeric(width) && nchar(res, type="width") > width){ delim <- c("(", rep(", ", length(x) - 1), ")") wrk <- paste(c(name, x), delim, sep="") lens <- nchar(wrk, type="width") if(!missing(realname)) lens[1] <- nchar(realname, type="width") + 1 indent <- paste(rep(" ", lens[1]), collapse="") res <- character(0) curlen <- 0 for(i in seq_along(wrk)){ if(curlen + lens[i] > width){ res <- paste(res, "\n", indent, sep="") curlen <- lens[1] # = number of chars in `indent' } res <- paste(res, wrk[i], sep="") curlen <- curlen + lens[i] } } res } deparse_usage1 <- function(x, width = 72){ if(!x$fu) # a variable, not function return( structure( x$name, names = x$name ) ) # todo: maybe x$name tryabva da e character, as.character here should not be needed. if(as.character(x$name) %in% c("[","[[", "$", "@", "[<-", "[[<-", "$<-", "@<-", "!")) "dummy" else if(x$infix){ # infix operator if(grepl(".+<-$", x$name)){ # name end is "<-" but is not equal to it name2 <- sub("^(.+)<-$", "\\1", x$name) m <- length(x$argnames) res <- paste(name2, "(", paste(x$argnames[-m], collapse=", "), ")", "<-", x$argnames[m]) }else # todo: make sure that the name is not in quotes! res <- paste(x$argnames, collapse = paste0(" ", x$name, " ")) return(res) } res <- x$argnames names(res) <- x$argnames nams <- names(x$defaults) res[nams] <- paste(res[nams], "=", x$defaults) assop <- grepl(".+<-$", x$name) # name end is "<-" but is not equal to it name <- x$name if(assop){ name <- sub("<-$", "", x$name) value <- res[length(res)] res <- res[-length(res)] } res <- if(!identical(x$S3class, "")) format_funusage(res, paste("\\method{", name, "}{", x$S3class, "}", sep=""), realname = name ) else if(!identical(x$S4sig, "")) format_funusage(res, paste("\\S4method{", name, "}{", paste0(x$S4sig, collapse = ", "), "}", sep=""), realname = name ) else switch(name, "$" =, "@" = paste0(res[1], name, res[2]), "[" =, "[[" = paste0(res[1], name, paste0(res[-1], collapse = ", "), .closeOp[name]), "!" = paste0("!", res[1]), ## default format_funusage(res, name) ) if(assop) # if assignment, add to the last line, usually the only one res[length(res)] <- paste0(res[length(res)], " <- ", value) # "[<-" = paste0(res[1], "[", paste0(res[c(-1,-length(res))], # collapse = ", "), "]", " <- ", res[length(res)]), # "[[<-" = paste0(res[1], "[[", paste0(res[c(-1,-length(res))], # collapse = ", "), "]]", " <- ", res[length(res)]), # "$<-" = paste0(res[1], "$", res[2], " <- ", res[3]), # "@<-" = paste0(res[1], "@", res[2], " <- ", res[3]), res <- gsub("...", "\\dots", res, fixed=TRUE) structure( paste(res, collapse = ""), names=x$name ) } as.character.f_usage <- function(x,...){ deparse_usage1(x) } deparse_usage <- function (x){ if(class(x) == "f_usage") return(deparse_usage1(x)) nams <- names(x) if(!is.null(nams)) # remove names since sapply merges them with the names of names(x) <- NULL # the list obtained by lapply() res <- sapply(x, deparse_usage1) if(is.null(names(res))) # in most cases names(res) will be the same as nams names(res) <- nams # but give preference to the ones returned by # deparse_usage1 which takes names from the objects. # This `if' will hardly ever kick in... res } .closeOp <- list("[" = "]", "[[" = "]]", "(" = ")", "{" = "}") Rdpack/R/threedots.R0000644000175000017500000000424513501141722014136 0ustar nileshnilesh# > tools:::.strip_whitespace .strip_whitespace <- function (x) { x <- sub("^[[:space:]]+", "", x) x <- sub("[[:space:]]+$", "", x) x } ## tools:::.Rd_drop_nodes_with_tags, but tools:::RdTags(e) => Rdo_tags(e) toolsdotdotdot.Rd_drop_nodes_with_tags <- function (x, tags) { recurse <- function(e) { if (is.list(e)) structure(lapply(e[is.na(match(Rdo_tags(e), tags))], recurse), Rd_tag = attr(e, "Rd_tag")) else e } recurse(x) } ## > tools:::.Rd_get_metadata, but tools:::RdTags() => Rdo_tags() toolsdotdotdot.Rd_get_metadata <- function (x, kind) # e.g. kind = "keyword", see help page of Rd_db() { x <- x[Rdo_tags(x) == sprintf("\\%s", kind)] if (!length(x)) character() else unique(.strip_whitespace(sapply(x, as.character))) } ## > utils:::.getHelpFile utilsdotdotdot.getHelpFile <- function (file) { path <- dirname(file) dirpath <- dirname(path) if (!file.exists(dirpath)) stop(gettextf("invalid %s argument", sQuote("file")), domain = NA) pkgname <- basename(dirpath) RdDB <- file.path(path, pkgname) if (!file.exists(paste(RdDB, "rdx", sep = "."))) stop(gettextf("package %s exists but was not installed under R >= 2.10.0 so help cannot be accessed", sQuote(pkgname)), domain = NA) toolsdotdotdotfetchRdDB(RdDB, basename(file)) } ## > tools:::fetchRdDB toolsdotdotdotfetchRdDB <- function (filebase, key = NULL) { fun <- function(db) { vals <- db$vals vars <- db$vars datafile <- db$datafile compressed <- db$compressed envhook <- db$envhook fetch <- function(key) lazyLoadDBfetch(vals[key][[1L]], datafile, compressed, envhook) if (length(key)) { if (!key %in% vars) stop(gettextf("No help on %s found in RdDB %s", sQuote(key), sQuote(filebase)), domain = NA) fetch(key) } else { res <- lapply(vars, fetch) names(res) <- vars res } } res <- lazyLoadDBexec(filebase, fun) if (length(key)) res else invisible(res) } Rdpack/R/parse.R0000644000175000017500000000431413757414424013263 0ustar nileshnilesh## 2018-01-30 experimenting with processing of Rd macros ## pkgmacros <- tools::loadPkgRdMacros(system.file(package = package)) ## rdo <- parse_Rd(infile, macros = pkgmacros) ## 2018-01-30 new function ## as parse_Rd but intercepts warnings about unknown Rd macros permissive_parse_Rd <- function(file, permissive = TRUE, ...){ parse_Rd(file, permissive = permissive, ...) } ## 2018-01-30 new argument 'macros' .parse_Rdlines <- function(lines, macros = NULL){ tmpfile <- tempfile("Rdlines", fileext = ".Rd") # unlist is harmless if `lines' is already a character vector cat(unlist(lines), file = tmpfile, sep = "\n") # todo: catch errors if(is.null(macros)) res <- permissive_parse_Rd(tmpfile) # todo: catch errors else res <- permissive_parse_Rd(tmpfile, macros = macros) # todo: catch errors unlink(tmpfile) res } parse_Rdtext <- function(text, section = NA){ if(!is.na(section)) text <- c(paste(section,"{",sep=""), text, "}") res <- .parse_Rdlines(text) # write(text, sep="\n", file = file); res <- parse_Rd(file) rdtag <- attr(res[[1]], "Rd_tag") if(!is.na(section) && !is.null(rdtag) && rdtag==section) # todo: tova e krapka! res <- res[[1]] if(identical( c(res[[1]]), "\n" )) # c( ) to strip attributes res[[1]] <- NULL res } parse_Rdpiece <- function(x, result=""){ maket <- list_Rd(title="Dummy title" , name="dummyname" , "\\description"="Dummy description" , note = x , Rd_class=TRUE ) fn <- tempfile(pattern = "Rdpiece", fileext = "Rd") cat(as.character(maket), file=fn, sep="") # todo: error processing wrk <- permissive_parse_Rd(fn) unlink(fn) if(result=="text"){ # Rd_help2txt is from gbRd res <- gbRd::Rd_help2txt(wrk, keep_section="\\note", omit_sec_header=TRUE) }else{ indx <- Rdo_which_tag_eq(wrk, "\\note") res <- wrk[[indx]] if(!is.null(attr(res,"Rd_tag"))) attr(res,"Rd_tag") <- NULL } res } Rdpack/R/signature.R0000644000175000017500000002475113501141722014142 0ustar nileshnilesh # todo: need to setup error processing. E.g. in 2.14-0 signatures # for 'initialize-methods' in package 'methods' have an entry # with a duplicated signature which causes error. .get_signature <- function(rdo, pos){ sigtxt <- rapply(rdo[[pos]], function(x){ if(length(x)>1){ #when Rd_tag = "USERMACRO" "" }else if(grepl("^[ ]*signature\\(", x)){ wrk <- gsub("^[ ]*(signature\\([^)]*\\)).*", "\\1", x) # in case manual formatting has introduced more spaces. However, # this needs to be done more carefully. It would be best to # parse the signature rather than to scrape the string. On the # other hand, signatures are produced (usually) programmatically. gsub("[[:space:]]+", " ", wrk) }else "" }, classes = "character", deflt="") sigtxt[ sigtxt != ""] } .get_item_labsig <- function(rdo, pos, lab=TRUE){ label <- if(lab) .get_item_label(rdo, pos) else as.character(NA) sig <- .get_signature(rdo, pos) if(inherits(try(parse(text=sig),silent=TRUE), "try-error")){ txt <- parse_Rdpiece(rdo[[pos]],result="text") sig <- gsub("^.*(signature\\([^)]*\\)).*", "\\1", paste(txt,collapse=" ")) sig <- gsub("[[:space:]]+", " ", sig) sig <- gsub("'", "", sig) # krapka } c(name = label, signature = sig) } .get_top_signature <- function(rdo, pos = NULL, sec = "Methods", lab = TRUE){ if(is.null(pos)) pos <- .locate_top_items(rdo, sec) lapply(pos, function(x) .get_item_labsig(rdo, x, lab = lab) ) } # this inspect signatures in documentation of a class inspect_clmethods <- function(rdo, final = TRUE){ fullname <- .get.name_content(rdo)$name # name of the class, including suffix `-class' cur <- .capture_promptAny(fullname, final=final) # gather info about the actual methods curnames <- .get_top_labels(cur, "Methods") curitems <- .locate_top_items(cur, "Methods") cursigs <- .get_top_signature(cur, pos = curitems, sec = "Methods") rdonames <- .get_top_labels(rdo, "Methods") # gather info about rdo items <- .locate_top_items(rdo, "Methods") rdosigs <- .get_top_signature(rdo, pos = items, sec = "Methods") cmp <- .asym_compare(rdosigs, cursigs) # compare methods in rdo and cur indxnew <- cmp$i_new indxdrp <- cmp$i_removed if(length(indxnew)>0){ # Now make inference based on cmp. cat("Undocumented methods found.\n") # 2012-10-16 cat("Undocumented methods: ") cat("\tAdding items for them.\n") # print(cursigs[indxnew]) # print(cursigs[indxnew]) curnamesnew <- curnames[indxnew] # todo: some clean up of the code below. # todo: sort by function name (first arg. na \\item) newitems <- .get_subset(cur, curitems[indxnew], rdtag = "\\describe") newitems <- .nl_and_indent(newitems) # 2012-10-16 proverkata za empty items if(length(items) == 0){ # no \describe environment idescr <- .locate_sec_content(rdo, "Methods") if(length(idescr)==1 && is.na(idescr)){ # NA returned if no section Methods # todo: NA is inconvenient to check # not needed: methpos <- Rdo_get_insert_pos(rdo,"\\section") rdo <- Rdo_insert(rdo, char2Rdpiece("Functions with methods for this class:", "Methods", force.sec = TRUE ), newline = FALSE) idescr <- .locate_sec_content(rdo, "Methods") } rdo[[idescr]] <- c(rdo[[idescr]], list(newitems)) }else{ dindx <- .locate_enclosing_tag(rdo, items[[1]], "\\describe") wrk <- c(rdo[[dindx]], newitems ) # ne mozhe tolkova prosto ponezhe v rdo[[indx]] mozhe da ima i # drugi elementi osven \item (napr \n # rdo[[dindx]] <- structure(wrk[ order(c(curnames,rdonames)) ], # Rd_tag = "\\describe") wrk2 <- wrk allnams <- c(rdonames,curnamesnew) rdo[[dindx]] <- if(length(wrk2) == length(allnams)) # only only \item's present structure(wrk2[order(allnams)], Rd_tag = "\\describe") else structure(wrk2 , Rd_tag = "\\describe") } } if(length(indxdrp)>0){ # todo: maybe put this note in a section in rdo? cat("The following methods are no longer present:\n") print(rdosigs[indxdrp]) cat("\tPlease remove their descriptions manually.\n") } rdo } ## This inspects signatures in documentation of methods. Signatures in documentation of ## classes are stored somewhat differently. this was written before inspect_clmethods() and ## was geared towards using existing code for ordinary functions (mainly parse_usage_text() inspect_signatures <- function(rdo, package = NULL, sec = "Methods"){ rdosigs <- .get_top_signature(rdo, sec = "Methods", lab = FALSE) # process signatures sigtxt <- sapply(rdosigs, function(x) x["signature"]) # in `rdo' urdo <- parse_usage_text(sigtxt) curtxt <- get_sig_text(rdo, package=package) # process actual signatures ucur <- parse_usage_text(curtxt) # 2012-09-07 - may tryabva da varne samite elementi, ne technite indeksi. icomp <- .asym_compare(urdo, ucur) removed_sig <- urdo[ icomp$i_removed ] added_sig <- ucur[ icomp$i_new ] if(length(added_sig)>0){ cat(length(added_sig), "new signatures found.\n") # print(added_sig) cat("\tAdding items for them.\n") } # else cat("\tNo new signatures.\n") if(length(removed_sig)>0){ # for testing only; cat(length(removed_sig), "removed signatures:\n") # remove eventually print(removed_sig) }else cat("\tNo removed signatures.\n") list( changed = length(added_sig) != 0 | length(removed_sig) != 0 , added_sig = added_sig, removed_sig = removed_sig ) } # todo: It would be better to call promptMethods() to get the signatures but in version # R-2.13.x I had trouble with argument `where' (could not figure out how to use it to # restrict to funtions from a package; also, promptMethods() seems to call the deprecated # function getMethods()). Check how these things stand in R-2.14, there may be no problem # any more (checked, in 2.14-0 it is the same). # curtxt0 <- showMethods(fname, printTo=FALSE) # curtxt <- curtxt0[-1] # drop the description string # curtxt <- gsub("^[ ]*\\(inherited from[^)]*\\)[ ]*", "" , curtxt) # curtxt <- curtxt[ curtxt != "" ] # todo: improve! # curtxt <- paste("signature(", curtxt, ")", sep="") get_sig_text <- function(rdo, package = NULL){ # finds the actual signatures without fname <- .get.name_content(rdo)$short # using promptXXX functions meths <- if(is.character(package)) findMethodSignatures(fname,where = asNamespace(package)) else findMethodSignatures(fname) nammeths <- colnames(meths) # insert quotes to make this consistent with parse_usage_text(); # do it defensively (hardly necessary), in case they are already there sig <- apply(meths, c(1,2), function(x) if(!all( grepl("^\"",x))) paste("\"",x,"\"",sep="") else x) # get one column for each signature sig <- apply(sig, 1, function(x) paste(nammeths, x, sep=" = ") ) # adjust `sig' so that `paste()' would do the right thing sig <- if(is.matrix(sig)) apply( t(sig), 1, function(x) paste(x, collapse=", ")) else sig # a vector if one paste("signature(", sig, ")", sep="") } S4formals <- function(fun, ...){ # could be made S4 generic if(!is(fun, "MethodDefinition")) fun <- getMethod(fun, ...) #browser() ## 2019-04-21 was: ## # todo: check that this is ok ## formals(body(fun@.Data)[[c(2,3)]]) # if not, fall back to formals(m1) ## ## This resolves a very old 'todo' (see the commented text above). ## The hack above doesn't always work. Replace it it more enlightened approach. fff <- fun@.Data funbody <- body(fff) if(length(funbody) == 3 && identical(funbody[[1]], as.name("{")) && length(funbody[[2]]) == 3 && identical(funbody[[c(2,1)]], as.name("<-")) && identical(funbody[[c(2,2)]], as.name(".local")) && is.function(funbody[[c(2,3)]]) ){ ## this is the old hack: formals(body(fun@.Data)[[c(2,3)]]) formals(funbody[[c(2,3)]]) }else{ formals(fff) } } # showMethods("plot") # showMethods("plot",includeDefs=TRUE) # showMethods("plot",includeDefs=TRUE,print=FALSE) # s <- showMethods("plot",includeDefs=TRUE, print=FALSE) # # # m1 <- getMethod("plot",c(x="profile.mle", y="missing")) # # class(m1) # showClass(class(m1)) # # m1 # m1@defined # m1@target # m1@.Data # # str(m1) # # formals(m1) # # m1@.Data # m1body <- body(m1@.Data) # m1body # m1body[[1]] # `{` # m1body[[2]] # the expression: .local <- function(...) ... # class(m1body[[2]]) # "<-" # m1body[[c(2,1)]] # `<-` # m1body[[c(2,2)]] # .local # m1body[[c(2,3)]] # the function, what I need # formals(m1body[[c(2,3)]]) # the formals ! Rdpack/R/inspect.R0000644000175000017500000002311313501141722013575 0ustar nileshnilesh.parse_long_name <- function(fnam){ # 2012-11-04 new, code from .capture_promptAny() namreg <- "^(.+)-([^-]+)$" if(grepl(namreg, fnam)){ # fnam is of the form xxxx-yyy (non-empty rhs) fname <- gsub(namreg, "\\1", fnam) type <- gsub(namreg, "\\2", fnam) # without "-" ## suffix <- gsub("^([^-]+)(-.*)", "\\2", fnam) # with "-" }else{ fname <- fnam type = "" } c(name = fname, type = type) } parse_Rdname <- function(rdo){ # 2012-10-01 todo: Rdpack-internal ste dade type="internal" # 2012-10-01 otkomentiram tova, to raboteshe vyarno po sluchaynost! # (ponezhe gsub() po-dolu go prevrasta v character()!) # nam <- rdo[[ which( tools:::RdTags(rdo) == "\\name" ) ]] ind <- Rdo_which_tag_eq(rdo, "\\name") nam <- c( rdo[[ c(ind, 1) ]]) # assumes length(ind) == 1 # 2012-11-04 changed with the code after the commented out section # # if(grepl("^([^-]+)-.*", nam)){ # nam is of the form xxxx-yyy # fname <- gsub("^([^-]+)-.*", "\\1", nam) # type <- gsub("^([^-]+)-(.*)", "\\2", nam) # suffix without the '-' # # suffix <- gsub("^([^-]+)(-.*)", "\\2", nam) # with the "-" # }else{ # fname <- nam # type = "" # } wrknam <- .parse_long_name(nam) fname <- wrknam["name"] type <- wrknam["type"] # malko kato krapka doctype <- Rdo_which_tag_eq(rdo, "\\docType") if(length(doctype) > 0 && type == "" ){ # todo: sravni s gornoto! type <- c( rdo[[ c(doctype[1],1) ]] ) # wrap n c() to remove attr. } list(fname = fname, type = type) } inspect_Rd <- function(rdo, package = NULL){ # rdo: Rd object or file name if(is.character(rdo) && length(rdo)==1) rdo <- permissive_parse_Rd(rdo) if(!inherits(rdo, "Rd") && is.null(attr(rdo,"Rd_Tag"))) return(structure(FALSE, details = "inspect_Rd: 1st arg. must be an Rd object or filename.")) type <- toolsdotdotdot.Rd_get_metadata(rdo,"docType") if(length(type) == 0){ type <- parse_Rdname(rdo)$type # todo: clean up if(!(type %in% c("package", ""))) # for now; there is, e.g. ts-methods which type <- "" # describes S3 methods. } switch(type, methods = inspect_Rdmethods(rdo, package = package), class = inspect_Rdclass(rdo), package = {cat("Currently reprompt for packages is not implemented.", "\tHowever, you could use the function promptPackageSexpr()", "\tto create a self-updating shell. 'promptPackageSexpr'", "\tis like 'promptPackage' but uses \\Sexpr commands rather", "\tthan strings for automatically generated information.", "Returning the Rd object unchanged.\n", sep = "\n") rdo }, data = {cat("Currently reprompt for data is not available.", "Returning the Rd object unchanged.\n", sep = "\n") rdo }, ## default inspect_Rdfun(rdo) ) } inspect_Rdclass <- function(rdo){ # rdo: Rd object cur <- inspect_slots(rdo) # methods: items have the form \item{fname}{signature}, ## 2018-08-27 - non-exiting class (TDO: check if it could be something else here ## TODO: think of a better way to handle this. if(inherits(cur, "try-error")){ cat(cur) return(rdo) } rdo <- inspect_clmethods(cur) # compare with those from promptClass rdo # todo: inspect other things too? } inspect_Rdmethods <- function(rdo, package = NULL){ # rdo: Rd object i_usage <- inspect_signatures(rdo, package = package) # i_usage$added_sig # i_usage$removed_sig if(i_usage$changed) cat("\tMethods in the documentation are not the same as the current ones.\n") # 2014-08-23 new 'if' to tell the user to removed the doc. of non-existen methods if(length(i_usage$removed_sig) > 0){ cat("\tMethods for the following signatures ", "where not found", if(is.null(package)) "" else paste0(" in package ", package) , ":\n", sep = "") for( sigus in i_usage$removed_sig){ txt <- paste(sigus$argnames, sigus$defaults, collapse = ",\t", sep = " = ") cat("\t ", txt, "\n") } # 2014-08-23 todo: maybe give a more cautious advice here? cat("\tPlease remove these from the documentation.\n\n") } if(length(i_usage$added_sig) > 0){ cat("\tAppending new signatures to section \"Methods\"\n") ## 2014-08-23 TODO: ## the code below now is executed only when length(i_usage$added_sig) > 0; ## before it was executed whenever i_usage$changed was TRUE. newsigs <- sapply(i_usage$added_sig, function(x) deparse_usage1(x)) wrk <- lapply(c(newsigs), Rdo_sigitem) # todo: slozhi blank line predi vseki item, names(wrk) <- NULL # no da ne e chast ot itemite, # a mezhdu tyach. idescr <- .locate_top_tag(rdo, "Methods") if(length(idescr) == 0){ # no descibe enviroment there. wrk <- Rdo_macro(wrk, "\\describe") idescr <- .locate_sec_content(rdo, "Methods") rdo[[idescr]] <- c(rdo[[idescr]], list(wrk)) }else rdo <- append_to_Rd_list(rdo, wrk, pos = idescr) } # 2012-09-07 new; not under the if above, # since aliases may be mismatched by manual editing (or otherwise) rdo <- update_aliases_tmp(rdo, package = package) # if "\\usage" section exists. if(length(Rdo_which_tag_eq(rdo, "\\usage")) > 0) rdo <- inspect_Rdfun(rdo, alias_update = FALSE) # alias_update was added to Rd_fun # to be used here rdo } # todo: more systematic messages about what has changed (or not) inspect_Rdfun <- function(rdo, alias_update = TRUE){ # rdo: Rd object i_usage <- inspect_usage(rdo) if(length(i_usage) == 0) # todo: processing of arguments may still be needed here return(rdo) i_args <- inspect_args(rdo, i_usage) # 2011-12-08 new; corresponding additions to compare_usage1 # 2012-10-05 slagam as.character, ponezhe nyakoi mozhe da sa ot class `name` # todo: make sure that they are character in the first place? aliases <- sapply(i_usage, function(x) as.character(attr(x, "details")$alias)) aliases <- aliases[aliases != ""] rdoaliases <- Rdo_collect_aliases(rdo) # 2012-10-05 promenyam za da otchitam #ifdef new_aliases <- aliases[ !(aliases %in% rdoaliases) ] if(alias_update && length(new_aliases) > 0) # update the aliases for(alias in unique(new_aliases)) rdo <- Rdo_insert(rdo, char2Rdpiece(alias, "alias")) flag_removed <- sapply(i_usage, function(x) attr(x, "details")$obj_removed) if(any(flag_removed)){ nams_removed <- sapply(i_usage, function(x) attr(x, "details")$rdo_usage$name) nams_removed <- nams_removed[flag_removed] obs_aliases <- nams_removed[ nams_removed %in% rdoaliases ] cat("The following objects are no longer described in this Rd object\n") cat("but it contains alias entries for them:\n") cat("\t", paste(obs_aliases), "\n") cat("You may wish to remove these \\alias{} entries from the Rd file.\n\n") } usage_changed <- !all( sapply(i_usage, identity)) # usage_changed <- TRUE # for testing if(usage_changed){ # update usage if changed f <- function(x){ a <- as.character(attr(x,"details")$cur_usage) parse_Rdtext(a, section = "\\usage") } u <- lapply(i_usage, f) u <- .Rdinter(u, before_first = TRUE) wrk <- structure(do.call("c", u), Rd_tag = "\\usage") rdo <- Rdo_replace_section(rdo, wrk) } # todo: Rdo_append_argument probably should check length(newargs)>0 anyway? if(!i_args){ # update arguments if changed newargs <- attr(i_args,"details")$added_argnames if(length(newargs)>0){ cat("\nnewargs is:", newargs, "\n") rdo <- Rdo_append_argument(rdo, newargs) } remargs <- attr(i_args,"details")$removed_argnames if(length(remargs)>0){ cat("Argument(s): ", remargs, "\n") cat("\tare no longer in any usage statements in this Rd object.\n") cat("Please remove the corresponding \\item's from section '\\arguments'.\n") cat("\n") } } rdo } Rdpack/R/sections.R0000644000175000017500000001733213501141722013765 0ustar nileshnilesh.sec_name <- function(x){ # this assumes that x is a section Rd piece. a <- attr(x, "Rd_tag") #TODO: paste tuk e prapka, dobavi treti element! if(a != "\\section") a else paste(as.character(x[[1]]), collapse="") # 'as' is to drop attributes } .sec_content <- function(x){ # this assumes that x is a section Rd piece. a <- attr(x, "Rd_tag") if(a != "\\section") x else x[[2]] } .order_sections <- function(rdo){ # todo: take care of empty lines at top level. old <- Rdo_tags(rdo) n <- length(rdo) newpos <- numeric(n) curpos <- 1 for(i in 1:length(.rd_sections)){ ind <- which(old == .rd_sections[i]) len <- length(ind) if(len > 0){ newpos[curpos:(curpos+len-1)] <- ind curpos <- curpos + len } } if(curpos < n){ # note everything in "old" accounted for. Can there be things # other than newlines? missedpos <- seq_len(n)[ !(seq_len(n) %in% newpos) ] # browser() # for testing newpos[curpos:n] <- missedpos # to make sure that nothing is omitted } if(identical(newpos, seq_along(newpos))){ rdo # nothing to reshuffle here }else{ res <- rdo[newpos] attributes(res) <- attributes(rdo) res } } .replace_dummy <- function(rdo, unchanged_titles){ secall <- Rdo_sections(rdo) for(sec in secall) if(sec$title %in% unchanged_titles) rdo[[ sec$pos ]] <- char2Rdpiece("dummy", sub("^\\\\", "", sec$title), force.sec = TRUE) rdo } .srcrefpos <- function(rdo, rdoorig, pos_list){ secall <- Rdo_sections(rdo) res <- vector(mode="list", length(pos_list)) ind <- 0 for(sec in secall){ pos <- .tmp_pos(sec$title, pos_list) if(!is.null(pos)){ ind <- ind + 1 res[[ind]] <- list(attr(rdo[[sec$pos]], "srcref"), attr(rdoorig[[pos]], "srcref")) } } res } .replace_from <- function(rdo, rdoorig, pos_list){ secall <- Rdo_sections(rdo) for(sec in secall){ pos <- .tmp_pos(sec$title, pos_list) if(!is.null(pos)) rdo[[sec$pos]] <- rdoorig[[pos]] } rdo } Rdo_sections <- function(rdo){ res <- Rdo_locate(rdo, function(x) .tag_in(x, .rd_sections), .sec_name, lists = TRUE, nested = FALSE) # 2012-10-20 new arg. nested used lapply(res, function(x){ names(x)[names(x) == "value"] <- "title"; x}) } Rdo_modify_simple <- function(rdo, text, section, ...){ val <- char2Rdpiece(text, section) Rdo_modify(rdo, val, ...) } Rdo_empty_sections <- function(rdo, with_bs = FALSE){ # rdo is Rd object or filename if(is.character(rdo)) rdo <- permissive_parse_Rd(rdo) pat <- ".*Dropping empty section[ ]+[\\](.*)$" wrk <- checkRd(rdo) ind <- grepl(pat, wrk) res <- gsub(".*Dropping empty section[ ]+[\\]", "", wrk[ind]) if(with_bs) res <- sapply(res, function(x) paste("\\",x,sep="")) # prepend backslash res } Rdo_drop_empty <- function(rdo, sec = TRUE){ # todo: drop other empty things? emptysec <- Rdo_empty_sections(rdo, with_bs = TRUE) rdotags <- Rdo_tags(rdo) stopifnot(length(rdotags) == length(rdo)) # paranoic; but tools:::RdTags above is # non-exported function res <- rdo[ !(rdotags %in% emptysec) ] class(res) <- class(rdo) res } # rd is a character vector of filenames Rdo_replace_section <- function(rdo, val, create = FALSE, replace = TRUE){ Rdo_modify(rdo, val, create=create, replace = replace) } Rdo_set_section <- function(text, sec, file, ...){ piece <- char2Rdpiece(text, sec) rdo <- Rdo_replace_section(permissive_parse_Rd(file), piece, ...) Rdo2Rdf(rdo, file = file) } # todo: this does not consider the possibility for #ifdef # return the location (full index) of the content of a section. for # standard sections this is at the top level but for user defined # sections it is deeper. see also tools:::.Rd_get_section .locate_sec_content <- function(rdo, sec, onlyone = TRUE){ # 2011-12-12 add 'more' arg. tags <- Rdo_tags(rdo) indx_sec <- which(tags == sec) # in case this is a standard section, todo: do it properly! if(length(indx_sec) > 0){ # standard section if(length(indx_sec) > 1 && onlyone){ warning("More than one section with this name, using the first one.") indx_sec <- indx_sec[[1]] } res <- indx_sec # for standard sections the content is simply that tagged list. }else{ # user section; todo: arg. 'onlyone' silently ignored here indx_sec <- which(tags == "\\section") if(length(indx_sec) > 0 ){ # wraps in c() here to get rid of attributes; # note also the two 1's in the index (seems # that each arg of "\\section" is a list). methindx <- sapply(indx_sec, function(x) identical(c(rdo[[c(x,1,1)]]), sec) ) indx_sec <- indx_sec[methindx] # take only those that match. } if(length(indx_sec) == 0) res <- NA # stop("No section `??'. Todo: create it instead of throwing an error.") else{ if(length(indx_sec)>1){ warning("More than 1 sections `Methods' found, using the first one.") indx_sec <- indx_sec[1] } res <- c(indx_sec,2) # for user sections the content is deeper. } } res } .rdo_equal_sections <- function(rdo1, rdo2, sections = NULL){ # todo: arg. sections ne se # izpolzva veche! wrk1 <- Rdo_remove_srcref(rdo1) wrk2 <- Rdo_remove_srcref(rdo2) sec1 <- Rdo_sections(wrk1) sec2 <- Rdo_sections(wrk2) nams1 <- sapply(sec1, function(x) x$title) nams2 <- sapply(sec2, function(x) x$title) u1nam <- names(which(table(nams1) ==1)) # u1nam <- .without_duplicates(nams1) u2nam <- names(which(table(nams2) ==1)) # u2nam <- .without_duplicates(nams2) unam <- intersect(u1nam, u2nam) i1 <- which(nams1 %in% unam) # 2012-10-22 dobavyam all.equal, for some reason sometimes # seeemingly identical things are not "identical", # e.g. Special.Rd dava takova nesto za details. # todo: tova e krapka razibirase. isame <- sapply(i1, function(x){ i2 <- which(nams2 == nams1[x]); if(length(i2)==1 && ( identical(wrk1[[sec1[[x ]]$pos]], wrk2[[sec2[[i2]]$pos]]) || isTRUE(all.equal(wrk1[[sec1[[x ]]$pos]], wrk2[[sec2[[i2]]$pos]])) )) i2 else NA }) # browser() isame <- isame[!is.na(isame)] res <- sec2[isame] res } # tools:::.Rd_get_name # tools:::.Rd_deparse # # . function (x, sec) # get the Rd # { # x <- .Rd_get_section(x, "section") # if (length(x)) # .strip_whitespace(.Rd_deparse(x, tag = FALSE)) # else character() # } # list_files_with_exts("./man","Rd") # list_files_with_type("./man","docs") # Rdo_replace_section(a, char2Rdpiece("documentation", "keyword"), replace = "Rd") # files <- list_files_with_exts(dir, "Rd") Rdpack/R/bib.R0000644000175000017500000013667114177430165012716 0ustar nileshnilesh## Do not edit this file manually. ## It has been automatically generated from *.org sources. # TODO: krapka! .patch_latex <- function(txt){ # print(bibentry,"latex") inserts \bsl macros. gsub("\\bsl{}", "", txt, fixed=TRUE) } ## maybe add to package `gbutils'? ## ## if `wd' is a subdirectory of `string' return the path upto and including `string', ## otherwise return NULL. ## If not NULL, it is guaranteed that basename(wd) == string ## NOTE: currently doesn't expand `./', etc.. in_subdirectory <- function(string, wd = getwd()){ if(grepl(string, wd)){ packpat <- paste0(string, "$") while(!grepl(packpat, wd)){ wd <- dirname(wd) if(!grepl(string, wd)) return(NULL) } if(basename(wd) == string) wd else ## the found directory has `string' as a suffix, eg. xxxRdpack, not Rdpack NULL }else NULL } get_bibentries <- function(..., package = NULL, bibfile = "REFERENCES.bib", url_only = FALSE, stop_on_error = TRUE){ if(is.null(package)){ fn <- file.path(..., bibfile) ## check for existence of fn (and length(fn) == 1)? (but see below) }else{ ## first check for development mode in "devtools" ## if the current directory is under `package', first look for the file there devdir <- in_subdirectory(package) if(is.null(devdir)) fn <- "" else{ ## if in development dir of `package', get it from there fn <- file.path(devdir, "inst", ..., bibfile) if(length(fn) > 1){ warning("More than one file found, using the first one only.") fn <- fn[1] } if(!file.exists(fn)) fn <- "" } if(fn == "") ## if the above didn't succeed, try system.file(). In principle, this should work ## also in development mode under devtools, at least for REFERENCES.bib, ## but currently devtools' system.file() doesn't handle it. fn <- system.file(..., bibfile, package = package) if(fn == "") ## if the above didn't succeed try system.file() with subdir "inst". ## This is really for the case when system.file() is the one from devtools, ## see the note above. TODO: check if this is the case? fn <- system.file("inst", ..., bibfile, package = package) ## 2020-09-27 removing this functionality since package 'bibtex' ca no longer be ## relied upon and was dropped from the dependencies. ## ## if(length(fn) == 1 && fn == "") ## ## if system.file() didn't find the bib file, check if file package.bib is ## ## provided by package "bibtex" (it is for core R packages, such as "base") ## fn <- system.file("bib", sprintf("%s.bib", package), package = "bibtex") } if(length(fn) > 1){ warning("More than one file found, using the first one only.") fn <- fn[1] }else if(length(fn) == 1 && fn == ""){ msg <- paste0("Couldn't find file ", file.path(..., bibfile), if(!is.null(package)) paste0(" in package `", package, "'")) if(stop_on_error) stop(msg) else{ warning(msg) ## return an empty bibentryRd object res <- bibentry() class(res) <- c("bibentryRd", class(res)) return(res) } } ## 2018-10-03 ## use package's encoding if specified. ## TODO: maybe this function should have argument 'encoding' ## TODO: in principle the Rd file may have its own encoding, ## but my current understanding is that parse_Rd() first converts it to UTF-8. ## BUT what is the encoding of the strings in the object returned by read.bib? encoding <- if(!is.null(package) && !is.null(utils::packageDescription(package)$Encoding)) utils::packageDescription(package)$Encoding else "UTF-8" ## 2020-09-22 switching to 'rbibutils ## res <- read.bib(file = fn, encoding = encoding) ## current: res <- readBib(file = fn, encoding = encoding) ## test: res <- if(packageVersion("rbibutils") > '2.2.4') ## issue #7 in rbibutils readBib(file = fn, encoding = encoding, direct = TRUE, texChars = "Rdpack") else if(packageVersion("rbibutils") >= '2.1.2') readBib(file = fn, encoding = encoding, direct = TRUE) else readBib(file = fn, encoding = encoding) # 2018-03-10 commenting out # since bibtex v. >= 0.4.0 has been required for a long time in DESCRIPTION # # ## 2016-07-26 Now do this only for versions of bibtex < '0.4.0'. # ## From bibtex '0.4.0' read.bib() sets the names. # if(packageVersion("bibtex") < '0.4.0'){ # names(res) <- sapply(1:length(res), function(x) bibentry_key(res[[x]][[1]])) # } ## 2020-10-02 commenting out since taken care (hopefully) by readBib ## # for(nam in names(res)){ # ## unconditionaly recode %'s in filed URL # if(!is.null(res[nam]$url)) { # res[nam]$url <- gsub("([^\\])%", "\\1\\\\%", res[nam]$url) # } # # if(url_only){ # process also other fields # ## TODO: currently all unescaped %'s in all fields are recoded; # ## Maybe do it more selectively, e.g. only for %'s inside \url{}, # ## or matching something like http(s):// # fields <- names(unclass(res[nam])[[1]]) # # unclassed <- unclass(res[nam]) # flag <- FALSE # for(field in fields){ # wrk <- unclass(res[nam])[[1]][[field]] # if(is.character(wrk) && any(grepl("([^\\])%", wrk))){ # flag <- TRUE # unclassed[[1]][[field]] <- gsub("([^\\])%", "\\1\\\\%", wrk) # } # } # if(flag){ # class(unclassed) <- class(res[nam]) # res[nam] <- unclassed # } # } # } ## new 2020-10-02 - allow \% in url's and doi's in the bib file for(nam in names(res)){ # print(res[nam], style = "R") ## unconditionaly recode %'s in filed URL if(!is.null(res[nam]$doi)) { res[nam]$doi <- gsub("([^\\\\])[\\\\]%", "\\1%", res[nam]$doi) } if(!is.null(res[nam]$url)) { res[nam]$url <- gsub("([^\\\\])[\\\\]%", "\\1%", res[nam]$url) } # if(url_only){ # process also other fields # ## TODO: currently all unescaped %'s in all fields are recoded; # ## Maybe do it more selectively, e.g. only for %'s inside \url{}, # ## or matching something like http(s):// # fields <- names(unclass(res[nam])[[1]]) # # unclassed <- unclass(res[nam]) # flag <- FALSE # for(field in fields){ # wrk <- unclass(res[nam])[[1]][[field]] # if(is.character(wrk) && any(grepl("([^\\])%", wrk))){ # flag <- TRUE # unclassed[[1]][[field]] <- gsub("([^\\])%", "\\1\\\\%", wrk) # } # } # if(flag){ # class(unclassed) <- class(res[nam]) # res[nam] <- unclassed # } # } } ## 2018-03-03 new: class(res) <- c("bibentryRd", class(res)) res } print.bibentryRd <- function (x, style = "text", ...){ class(x) <- class(x)[-1] ## TODO: It would be better to modify the entries and then call ## print(), rather than vice versa as now. res <- capture.output(print(x, style = style, ...)) res <- switch(tolower(style), r = gsub("\\\\\\\\%", "%", res), citation = , bibtex = gsub("\\\\%", "%", res), res ) cat(res, sep = "\n") } rebib <- function(infile, outfile, ...){ # 2013-03-29 rdo <- permissive_parse_Rd(infile) ## 2017-11-25 TODO: argument for RdMacros! if(missing(outfile)) outfile <- basename(infile) else if(identical(outfile, "")) # 2013-10-23 else clause is new outfile <- infile rdo <- inspect_Rdbib(rdo, ...) Rdo2Rdf(rdo, file=outfile, srcfile=infile) rdo } inspect_Rdbib <- function(rdo, force = FALSE, ...){ # 2013-03-29 # 2013-12-08 was: pos <- Rdo_locate_predefined_section(rdo, "\\references") pos <- Rdo_which_tag_eq(rdo, "\\references") if(length(pos) > 1) stop(paste("Found", length(pos), "sections `references'.\n", "There should be only one." )) else if(length(pos) == 0) # no section "references". return(rdo) bibs <- get_bibentries(...) fkey <- function(x){ m <- gregexpr("[ ]+", x) rm <- regmatches(x, m, invert = TRUE)[[1]] if(length(rm) >= 2 && rm[2] != "bibentry:") rm[2] # e.g. bibentry:all else if(length(rm) < 3) # % bibentry: xxx_key_xxx "" # NA_character_ else rm[3] } fbib <- function(x) grepl("[ ]+bibentry:", x) posbibs <- Rdo_locate(rdo[[pos]], f = fbib, pos_only = fkey) poskeys <- sapply(posbibs, function(x) x$value) print(posbibs) fendkey <- function(x){ m <- gregexpr("[ ]+", x) rm <- regmatches(x, m, invert = TRUE)[[1]] if(length(rm) >= 2 && rm[2] != "end:bibentry:") rm[2] # e.g. end:bibentry:all else if(length(rm) < 3) # % end:bibentry: xxx_key_xxx "" # NA_character_ else rm[3] } fendbib <- function(x) grepl("end:bibentry:", x) posendbibs <- Rdo_locate(rdo[[pos]], f = fendbib, pos_only = fendkey) posendkeys <- sapply(posendbibs, function(x) x$value) toomit <- which(poskeys %in% posendkeys) # note: en@bibkeys:all is different! todo: if(length(toomit) > 0 && !force){ poskeys <- poskeys[-toomit] posbibs <- posbibs[-toomit] } if(length(poskeys)==0) "nothing to do." else if(any(poskeys == "bibentry:all")){ poskey <- posbibs[[ which(poskeys == "bibentry:all") ]]$pos ## 2021-04-29 TODO: the following line(s) needs to be replaced with ## .toRd_styled(bibs[poskeys[i], ???) ## For testing use REFERENCES.bib in rbibutils ## (the doi's are currently rendered horribly) ## DONE! was: # bibstxt <- capture.output(print(bibs, "latex")) # # bibstxt <- .patch_latex(bibstxt) # TODO: krapka! ## TODO: the bibstyles used beloww should probably be arguments bibs <- sort(bibs, .bibstyle = "JSSRd") bibstxt <- .toRd_styled(bibs, "Rdpack") # bibstxt <- paste0(bibstxt, collapse = "\\cr\\cr ") bibstxt <- paste0(bibstxt, collapse = "\n\n ") bibstxt <- paste(c("", bibstxt), "\n", sep="") endbibline <- Rdo_comment("% end:bibentry:all") keyflag <- "end:bibentry:all" %in% posendkeys if(keyflag && force){ #todo: more careful! endposkey <- posendbibs[[ which(posendkeys == "end:bibentry:all") ]]$pos rdo[[pos]] <- Rdo_flatremove(rdo[[pos]], poskey+1, endposkey) } if(!keyflag || force){ rdo[[pos]] <- Rdo_flatinsert(rdo[[pos]], list(endbibline), poskey, before = FALSE) rdo[[pos]] <- Rdo_flatinsert(rdo[[pos]], bibstxt, poskey, before = FALSE) } }else{ for(i in length(poskeys):1){ bibkey <- posbibs[[i]]$value poskey <- posbibs[[i]]$pos ## 2021-04-29 TODO: the following line(s) needs to be replaced with ## .toRd_styled(bibs[poskeys[i], ???) ## For testing use REFERENCES.bib in rbibutils ## (the doi's are currently rendered horribly) ## DONE! was: # bibstxt <- capture.output(print(bibs[poskeys[i]],"latex")) # # bibstxt <- .patch_latex(bibstxt) # TODO: krapka! bibstxt <- .toRd_styled(bibs[poskeys[i]], "Rdpack") bibstxt <- list( paste( c("", bibstxt), "\n", sep="") ) endbibline <- Rdo_comment(paste("% end:bibentry: ", bibkey)) keyflag <- bibkey %in% posendkeys if(keyflag && force){ #todo: more careful! endposkey <- posendbibs[[ which(posendkeys == bibkey) ]]$pos rdo[[pos]] <- Rdo_flatremove(rdo[[pos]], poskey+1, endposkey) } if(!keyflag || force){ # this is always TRUE here but is left for common look # with "all". todo: needs consolidation rdo[[pos]] <- Rdo_flatinsert(rdo[[pos]], list(endbibline), poskey, before = FALSE) rdo[[pos]] <- Rdo_flatinsert(rdo[[pos]], bibstxt, poskey, before = FALSE) } } } rdo } Rdo_flatremove <- function(rdo, from, to){ # 2013-03-30 todo: more careful! res <- rdo[-(from:to)] attributes(res) <- attributes(rdo) # todo: more guarded copying of attributes? res } # todo: move to another file later Rdo_flatinsert <- function(rdo, val, pos, before = TRUE){ # 2013-03-29 depth <- length(pos) if(depth > 1){ rdo[[pos]] <- Recall(rdo[[ pos[-depth] ]], val, pos[-depth]) # todo: dali zapazva attributite na rdo? return(rdo) } n <- length(rdo) if(!before) pos <- pos + 1 res <- if(pos==1) c(val, rdo) else if(pos==n+1) c(rdo, val) else c( rdo[1:(pos-1)], val, rdo[pos:n]) attributes(res) <- attributes(rdo) # todo: more guarded copying of attributes? res } ## 2020-11-01: use local() .bibs_cache <- local({ ## initialise the cache ## TODO: remove refsmat, it is not needed here, maybe refsmat <- matrix(character(0), nrow = 0, ncol = 2) allbibs <- list() ## TODO: time stamp for auto clearing .get_bibs0 <- function(package, ..., cached_env) { if(is.null(package)) stop("argument 'package' must be provided") bibs <- allbibs[[package]] if(is.null(bibs)){ ## message(" bibs is NULL") bibs <- get_bibentries(package = package, ..., stop_on_error = FALSE) allbibs[[package]] <<- bibs } ## else ## message(" bibs is nonNULL") bibs } .get_all_bibs <- function(){ allbibs } list(.get_bibs0 = .get_bibs0, .get_all_bibs = .get_all_bibs) }) ## TODO: auto-deduce 'package'? ## 2020-09-30: changing to cache bib as \insertCite does (new arg. cached_env, etc) insert_ref <- function(key, package = NULL, ..., cached_env = NULL) { # 2020-09-30: replaced by a single call # if(is.null(package)) # stop("argument 'package' must be provided") # # bibs <- get_bibentries(package = package, ..., stop_on_error = FALSE) # # TODO: this is for testing only! # message("\nkey is ", key) # if(is.null(cached_env)) # message(" cached_env is NULL") # else # message(" cached_env is nonNULL") bibs <- .bibs_cache$.get_bibs0(package, ..., cached_env = cached_env) if(length(bibs) == 0){ note <- paste0("\"Failed to insert reference with key = ", key, " from package = '", package, "'.", " Possible cause --- missing REFERENCES.bib in package '", package, "' or '", package, "' not installed.\"" ) note <- paste0("\\Sexpr[results=rd,stage=install]{{warning(", note, ");", note, "}} ") item <- bibentry( bibtype = "Misc", title = "Not avalable", author = person("A", "Adummy"), year = format(Sys.time(), "%Y"), note = note, key = key ) .toRd_styled(item, package) }else if(length(key) == 1){ item <- tryCatch(bibs[[key]], warning = function(c) { if(grepl("subscript out of bounds", c$message)){ ## tell the user the offending key. s <- paste0("possibly non-existing key '", key, "'") c$message <- paste0(c$message, " (", s, ")") } warning(c) # res <- paste0("\nWARNING: failed to insert reference '", key, # "' from package '", package, "' - ", # s, ".\n") # return(res) ## setup a dummy entry bibentry( bibtype = "Misc", title = "Not avalable", author = person("A", "Adummy"), year = format(Sys.time(), "%Y"), note = paste0("Failed to insert reference with key = ", key, " from package = '", package, "'.", " Possible cause --- missing or misspelled key." ), key = key ) }) # # 2018-03-01 Bug: Unexpected END_OF_INPUT error (URL parsing?) #3 # # I don't know why toRd() doesn't do this... # # # # escape percents that are not preceded by backslash # # (`if' is because in case of error above, item will be simply a string) # # Commenting out since get_bibentries() does it. # if(inherits(item, "bibentry") && !is.null(item$url)) # item$url <- gsub("([^\\])%", "\\1\\\\%", item$url) # if(interactive()) browser() # wrk <- .toRd_styled(item, package) # TODO: add styles? (doesn't seem feasible here) # fn <- tempfile() # cat(wrk, file = fn) # res <- permissive_parse_Rd(fn) ## tools::parse_Rd(fn) # tools::toRd(res) # # wrk <- .toRd_styled(item, package) # Encoding(wrk) <- "bytes" # wrk # .toRd_styled(item, package) }else{ ## key is documented to be of length one, nevertheless handle it too kiki <- FALSE items <- withCallingHandlers(bibs[[key]], warning = function(w) {kiki <<- TRUE}) ## TODO: deal with URL's as above txt <- .toRd_styled(items, package) if(kiki){ # warning(s) in bibs[[key]] s <- paste0("WARNING: failed to insert ", "one or more of the following keys in REFERENCES.bib:\n", paste(key, collapse = ", \n"), ".") warning(s) txt <- c(txt, s) } paste0(paste(txt, collapse = "\n\n"), "\n") } } ## 2017-11-25 new ## see utils:::print.help_files_with_topic() viewRd <- function(infile, type = getOption("help_type"), stages = NULL){ infile <- normalizePath(infile) if(is.null(type)) type <- "text" else if(!is.character(type) || length(type) != 1) stop("'type' should be 'html' or 'text'") if(is.null(stages)) # stages <- c("install", "render") stages <- c("build", "install", "render") # stages <- c("build", "render") else if(!is.character(stages) || !all(stages %in% c("build", "install", "render"))) stop('stages must be a character vector containing one or more of the strings "build", "install", and "render"') pkgname <- basename(dirname(dirname(infile))) outfile <- tempfile(fileext = paste0(".", type)) ## 2020-05-19: added pkgdir to read also current package macros, see below pkgdir <- dirname(dirname(infile)) ## here we need to expand the Rd macros, so don't use permissive_parse_Rd() ## 2020-05-19: read also the macros from pkgdir, ## load those from Rdpack anyway, in case Rdpack is not in 'DESCRIPTION' yet ## TODO: could issue warning here but this could be intrusive here since ## the user may not need Rdpack for the current package. e <- tools::loadPkgRdMacros(system.file(package = "Rdpack")) e <- tools::loadPkgRdMacros(pkgdir, macros = e) ## finally load the Rd system macros (though I haven't noticed errors without this step). e <- tools::loadRdMacros(file.path(R.home("share"), "Rd", "macros", "system.Rd"), macros = e) ## check if mathjaxr is needed descpath <- file.path(pkgdir, "DESCRIPTION") need_mathjaxr <- if(file.exists(descpath)){ ## rdmac is NA if there is no RDMacros field in DESCRIPTION rdmac <- as.character(read.dcf(descpath, fields = "RdMacros")) grepl("mathjaxr", as.character(rdmac)) }else{ ## try installed package pkgdesc <- packageDescription(pkgname) !is.null(pkgdesc$RdMacros) && grepl("mathjaxr",pkgdesc$RdMacros) } ## this loads mathjax from CDN, so internet connection needed if(need_mathjaxr){ ## code borrowed from package "mathjaxr" mjcdn <- Sys.getenv("MATHJAXR_USECDN") on.exit(Sys.setenv(MATHJAXR_USECDN = mjcdn)) Sys.setenv(MATHJAXR_USECDN = "TRUE") } ## Rdo <- parse_Rd(infile, macros = e) ## can't do this (the file may be deleted before the browser opens it): ## on.exit(unlink(outfile)) switch(type, text = { temp <- tools::Rd2txt(infile, # was: Rdo, out = outfile, package = pkgname, stages = stages , macros = e) file.show(temp, delete.file = TRUE) # text file is deleted }, html = { temp <- tools::Rd2HTML(infile, # was: Rdo, out = outfile, package = pkgname, stages = stages , macros = e) browseURL(temp) ## html file is not deleted }, stop("'type' should be one of 'text' or 'html'") ) } ## temporary; not exported vigbib <- function(package, verbose = TRUE, ..., vig = NULL){ if(!is.null(vig)) return(makeVignetteReference(package, vig, ...)) vigs <- vignette(package = package) if(nrow(vigs$results) == 0){ if(verbose) cat("No vignettes found in package ", package, "\n") return(bibentry()) } wrk <- lapply(seq_len(nrow(vigs$results)), function(x) makeVignetteReference(package = package, vig = x, verbose = FALSE, ...) ) res <- do.call("c", wrk) if(verbose) print(res, style = "Bibtex") invisible(res) } makeVignetteReference <- function(package, vig = 1, verbose = TRUE, title, author, type = "pdf", bibtype = "Article", key = NULL ){ publisher <- NULL # todo: turn this into an argument some day ... if(missing(package)) stop("argument 'package' is missing with no default") cranname <- "CRAN" cran <- "https://CRAN.R-Project.org" cranpack <- paste0(cran, "/package=", package) ## todo: for now only cran if(is.null(publisher)){ publisher <- cran publishername <- cranname publisherpack <- cranpack } desc <- packageDescription(package) vigs <- vignette(package = package) if(is.character(vig)){ vig <- pmatch(vig, vigs$results[ , "Item"]) if(length(vig) == 1 && !is.na(vig)){ wrk <- vigs$results[vig, "Title"] }else stop(paste0( "'vig' must (partially) match one of:\n", paste0("\t", 1:nrow(vigs$results), " ", vigs$results[ , "Item"], "\n", collapse = "\n"), "Alternatively, 'vig' can be the index printed in front of the name above.")) }else if(1 <= vig && vig <= nrow(vigs$results)){ wrk <- vigs$results[vig, "Title"] }else{ stop("not ready yet, should return all vigs in the package.") } if(missing(author)) author <- desc$Author title <- gsub(" \\([^)]*\\)$", "", wrk) # drop ' (source, pdf)' item <- vigs$results[vig, "Item"] vigfile <- paste0(item, ".", type) journal <- paste0("URL ", publisherpack, ".", " Vignette included in R package ", package, ", version ", desc$Version ) if(is.null(desc$Date)){ # built-in packages do not have field "year" if(grepl("^Part of R", desc$License[1])){ ## title <- paste0(title, "(", desc$License, ")") publisherpack <- cran ## do not add package=... to https in this case journal <- paste0("URL ", publisherpack, ".", " Vignette included in R package ", package, " (", desc$License, ")" ) } year <- R.version$year }else year <- substring(desc$Date, 1, 4) # stop(paste0("argument 'vig' must be a charater string or an integer\n", # "between 1 and the number of vignettes in the package")) if(is.null(key)) key <- paste0("vig", package, ":", vigs$results[vig, "Item"]) res <- bibentry( key = key, bibtype = bibtype, title = title, author = author, journal = journal, year = year, ## note = "R package version 1.3-4", publisher = publishername, url = publisherpack ) if(verbose){ print(res, style = "Bibtex") cat("\n") } res } ## 2018-03-13 new insert_citeOnly <- function(keys, package = NULL, before = NULL, after = NULL, bibpunct = NULL, ..., cached_env = NULL, cite_only = FALSE, dont_cite = FALSE) { if(!is.null(cached_env)){ if(is.null(cached_env$refsmat)) cached_env$refsmat <- matrix(character(0), nrow = 0, ncol = 2) ## if(is.null(cached_env$allbibs)) ## cached_env$allbibs <- list() } if(is.null(package)) stop("argument 'package' must be provided") if(length(keys) > 1) stop("`keys' must be a character string") if(!cite_only) cached_env$refsmat <- rbind(cached_env$refsmat, c(keys, package)) if(dont_cite) return(character(0)) nobrackets <- grepl(";nobrackets$", keys) # new 2022-02-05; related to issue #23 if(nobrackets) keys <- gsub(";nobrackets$", "", keys) textual <- grepl(";textual$", keys) if(textual) keys <- gsub(";textual$", "", keys) if(grepl("[^a-zA-Z.0-9]", package)){ delims <- gsub("[a-zA-Z.0-9]", "", package) ch <- substr(delims, 1, 1) wrk <- strsplit(package, ch, fixed = TRUE)[[1]] # note: [[1]] package <- wrk[1] if(length(wrk) > 1){ if(nchar(wrk[2]) > 1 || nchar(wrk[2]) == 1 && wrk[2] != " ") before <- wrk[2] if(length(wrk) > 2 && (nchar(wrk[3]) > 1 || nchar(wrk[3]) == 1 && wrk[3] != " ")) after <- wrk[3] } } # 2020-11-05 was: # # if(is.null(cached_env)){ # bibs <- get_bibentries(package = package, ..., stop_on_error = FALSE) # }else{ # bibs <- cached_env$allbibs[[package]] # if(is.null(bibs)){ # bibs <- get_bibentries(package = package, ..., stop_on_error = FALSE) # cached_env$allbibs[[package]] <- bibs # } # } # bibs <- .bibs_cache$.get_bibs0(package, ..., cached_env = cached_env) # This wouldn't work since roxygen2 will change it to citation # TODO: check # if(substr(keys, 1, 1) == "["){ # rmarkdown syntax (actually roxygen2?) # keys <- substr(keys, 2, nchar(keys) - 1) # drop "[" and the closing "]" # splitkeys <- strsplit(keys, ";", fixed = TRUE)[[1]] # note: [[1]] # # # # } refch <- "@" refchpat <- paste0("^[", refch, "]") if(grepl(refchpat, keys)){ ch <- substr(keys, 1, 1) # 'ch' is not used currently keys <- substr(keys, 2, nchar(keys)) # drop refch ## TODO: check if there are still @'s at this point refpat <- paste0("(", refch, "[^;,()[:space:]]+)") # "(@[^;,[:space:]]+)" if(textual){ wrkkeys <- strsplit(keys, "@")[[1]] # note [[1]] !!! ## the last key is special, since there is none after it nk <- length(wrkkeys) wrkkeys[nk] <- if(grepl("[;,]$", wrkkeys[nk])) sub("([;,])$", ")\\1", wrkkeys[nk]) else paste0(wrkkeys[nk], ")") ## the 2nd element contains the first key even if the string starts with '@' ## (if that is the case the first string is "") if(nk > 2){ for(i in 2:(nk - 1)){ wrkkeys[i] <- if(grepl("([;,][^;,]*)$", wrkkeys[i])) sub("([;,][^;,]*)$", ")\\1" , wrkkeys[i]) else sub("^([^;,()[:space:]]+)", "\\1)" , wrkkeys[i]) } } keys <- paste0(wrkkeys, collapse = refch) } m <- gregexpr(refpat, keys) allkeys <- regmatches(keys, m)[[1]] # note: [[1]] allkeys <- gsub(refch, "", allkeys) if(textual){ bibpunct0 = c("(", ")", ";", "a", "", ",") if(!is.null(bibpunct)){ if(length(bibpunct) < length(bibpunct0)) bibpunct <- c(bibpunct, bibpunct0[-seq_len(length(bibpunct))]) ind <- which(is.na(bibpunct)) if(length(ind) > 0) bibpunct[ind] <- bibpunct0[ind] }else bibpunct <- bibpunct0 }else{ ## for now ignore bibpunct in this case bibpunct <- c("", "", ";", "a", "", ",") } refs <- sapply(allkeys, function(key) safe_cite(key, bibs, textual = textual, bibpunct = bibpunct, from.package = package) ) if(textual){ ## drop ")" - strong assumption that that is the last char refs <- sapply(refs, function(s) substr(s, 1, nchar(s) - 1)) } ## replace keys with citations text <- keys regmatches(text, m) <- list(refs) ## parentheses around the whole cite; 2022-02-05: also if !nobrackets if(!textual && !nobrackets) # 2018-03-28 don't put parentheses in textual mode text <- paste0("(", text, ")") }else{ if(is.null(bibpunct)){ if(!textual && nobrackets) # 2022-02-05 bibpunct0 = c("", "", ";", "a", "", ",") else bibpunct0 = c("(", ")", ";", "a", "", ",") text <- safe_cite(keys, bibs, textual = textual, before = before, after = after, bibpunct = bibpunct0, from.package = package) }else{ bibpunct0 = c("(", ")", ";", "a", "", ",") if(length(bibpunct) < length(bibpunct0)) bibpunct <- c(bibpunct, bibpunct0[-seq_len(length(bibpunct))]) ind <- which(is.na(bibpunct)) if(length(ind) > 0) bibpunct[ind] <- bibpunct0[ind] text <- safe_cite(keys, bibs, textual = textual, before = before, after = after, bibpunct = bibpunct, from.package = package) } } toRd(text) } safe_cite <- function(keys, bib, ..., from.package = NULL){ wrk.keys <- unlist(strsplit(keys, ",")) if(!all(wrk.keys %in% names(bib))){ ok <- wrk.keys %in% names(bib) miss.keys <- wrk.keys[!ok] warning("possibly non-existing or duplicated key(s)", if(!is.null(from.package)) paste0(" in bib file from package '", from.package, "'"), ":\n ", paste(miss.keys, sep = ", "), "\n") keys <- wrk.keys[ok] } # 2018-06-02 was: cite(keys = keys, bib = bib, ...) cite(keys = keys, bib = bib, longnamesfirst = FALSE, ...) } insert_all_ref <- function(refs, style = ""){ if(is.environment(refs)){ refsmat <- refs$refsmat allbibs <- .bibs_cache$.get_all_bibs() # 2020-11-05 was: refs$allbibs if(is.null(allbibs)) ## TODO: this can be removed, since .get_all_bibs() allbibs <- list() ## returns an initialised list() }else{ refsmat <- refs allbibs <- list() } if(is.null(refs) || is.null(refsmat) || nrow(refsmat) == 0) ## Returning the empty string is probably preferable but 'R CMD check' does not see ## that the references are empty in this case (although the help system see this and ## drops the section "references". To avoid confusing the user, print some ## informative text. return("There are no references for Rd macro \\verb{\\insertAllCites} on this help page.") all.keys <- list() for(i in 1:nrow(refsmat)){ keys <- refsmat[i, 1] nobrackets <- grepl(";nobrackets$", keys) # new 2022-02-05; related to issue #23 if(nobrackets) keys <- gsub(";nobrackets$", "", keys) textual <- grepl(";textual$", keys) if(any(textual)) keys <- gsub(";textual", "", keys) refch <- "@" refchpat <- paste0("^[", refch, "]") if(grepl(refchpat, keys)){ ch <- substr(keys, 1, 1) keys <- substr(keys, 2, nchar(keys)) # drop refch refpat <- paste0("(", refch, "[^;,[:space:]]+)") # "(@[^;,[:space:]]+)" m <- gregexpr(refpat, keys) keys <- regmatches(keys, m)[[1]] # note: [[1]] keys <- gsub("@", "", keys) }else{ keys <- unlist(strsplit(keys, ",")) } package <- refsmat[i, 2] if(is.null(all.keys[[package]])) all.keys[[package]] <- keys else all.keys[[package]] <- c(all.keys[[package]], keys) } bibs <- NULL for(package in names(all.keys)){ cur <- unique(all.keys[[package]]) be <- allbibs[[package]] if(is.null(be)) be <- get_bibentries(package = package, stop_on_error = FALSE) if(length(be) == 0){ be <- bibentry( bibtype = "Misc", title = "Not avalable", author = person("A", "Adummy"), year = format(Sys.time(), "%Y"), note = paste0("Failed to insert reference with keys = \n ", paste0(cur, collapse = " "), "\n", "from package = '", package, "'.", " Possible cause --- missing REFERENCES.bib in package '", package, "' or '", package, "' not installed." ), key = paste0(cur, collapse = ":") ) }else if(all(cur != "*")){ be <- tryCatch( be[cur], warning = function(c) { if(grepl("subscript out of bounds", c$message)){ ## tell the user the offending keys. c$message <- paste0(c$message, " (", paste(cur, collapse = " "), "' from package '", package, "'", ")" ) } warning(c) ## setup a dummy entry dummy <- bibentry( bibtype = "Misc", title = paste0("Some keys from package ", package, " are not avalable"), author = person("A", "Adummy"), year = format(Sys.time(), "%Y"), note = paste0("Failed to insert reference with keys:\n ", paste0(cur, collapse = ", "), "\n", "from package = '", package, "'.", " Possible cause - missing REFERENCES.bib in package '", package, "' or '", package, "' not installed." ), key = paste0(cur, collapse = ":") ) c(be[cur], dummy) }) } if(is.null(bibs)) bibs <- be else bibs <- c(bibs, be) # TODO: duplicate keys in different packages? } bibs <- sort(bibs, .bibstyle = "JSSRd") # 2021-04-24 was: sort(bibs) pkgs <- names(all.keys) # \Sexpr[stage=build,results=hide]{requireNamespace("cvar")} # 2016-06-02 was: # if(length(pkgs) > 0){ # pkg <- pkgs[1] ## TODO: for now should do # if(!isNamespaceLoaded(pkg) && !requireNamespace(pkg) ) # sty <- NULL # else{ # sty <- Rdpack_bibstyles(pkg) # } # }else # sty <- NULL # # if(!is.null(sty)) # res <- sapply(bibs, function(x) tools::toRd(x, style = "JSSLongNames")) # else { # if(style == "") # res <- sapply(bibs, function(x) tools::toRd(x)) # else{ # res <- sapply(bibs, function(x) tools::toRd(x, style = "JSSLongNames")) # } # } pkg <- if(length(pkgs) > 0) ## TODO: for now should do pkgs[1] else character(0) res <- .toRd_styled(bibs, pkg) # 2018-10-01 use \par since pkgdown ignores the empty lines # TODO: needs further thought # was: # (for now restoring the old one, to check if pkgdown would consider this as a bug) # paste0(res, collapse = "\n\n") paste0(res, collapse = "\\cr\\cr ") } deparseLatexToRd <- function(x, dropBraces = FALSE) { result <- character() lastTag <- "TEXT" for (i in seq_along(x)) { a <- x[[i]] tag <- attr(a, "latex_tag") if (is.null(tag)) tag <- "NULL" switch(tag, VERB = , TEXT = , MACRO = , COMMENT = result <- c(result, a), BLOCK = result <- c(result, if (dropBraces && lastTag == "TEXT") Recall(a) else c("{", Recall(a), "}")), ENVIRONMENT = result <- c(result, "\\begin{", a[[1L]], "}", Recall(a[[2L]]), "\\end{", a[[1L]], "}"), ## MATH = result <- c(result, "$", Recall(a), "$"), MATH = result <- c(result, "\\eqn{", Recall(a), "}"), NULL = stop("Internal error, no tag", domain = NA) ) lastTag <- tag } paste(result, collapse="") } Rdpack_bibstyles <- local({ styles <- list() function(package, authors){ if((n <- nargs()) > 1){ styles[[package]] <<- authors }else if(n == 1) styles[[package]] else styles } }) .toRd_styled <- function(bibs, package, style = ""){ sty <- if(length(package) == 0) NULL else if(!isNamespaceLoaded(package) && !requireNamespace(package) ) NULL else Rdpack_bibstyles(package) # if(!is.null(sty)) # res <- sapply(bibs, function(x) tools::toRd(x, style = "JSSLongNames")) # else { # check style # if(style == ""){ # if(!("JSSRd" %in% tools::getBibstyle(all = TRUE))) # ## bibstyle_JSSRd() # set_Rdpack_bibstyle("JSSRd") # res <- sapply(bibs, function(x) tools::toRd(x, style = "JSSRd")) # }else{ # res <- sapply(bibs, function(x) tools::toRd(x, style = "JSSLongNames")) # } # } sty <- if(is.null(sty) && style == ""){ if(!("JSSRd" %in% tools::getBibstyle(all = TRUE))) set_Rdpack_bibstyle("JSSRd") "JSSRd" }else "JSSLongNames" f <- function(x){ if(!is.null(x$doi) && !is.null(x$url) && grepl(paste0("https?://doi.org/", x$doi), x$url)) x$url <- NULL ## (2021-10-13) TODO: regarding issue #7 in rbibutils ## to fix temporarilly, add here processing of author and editor fields ## to change \'i to \'\i, if any, see ## https://github.com/GeoBosh/rbibutils/issues/7#issuecomment-939852743 ## ## But 'author' fields are of class "person", so the following will not work: ## ## if(!is.null(x$author) && grepl("\\\\'i", x$author)) ## x$author <- gsub("\\\\'i", "\\\\'\\\\i", x$author), ## ## Processing the person field in each reference is not appealing. ## Maybe rbibutils should get texChars = "Rdpack" option and do whatever specific ## for Rdpack is needed. tools::toRd(x, style = sty) } ## TODO: check if these 'sapply()' preserves encodings, if set. res <- sapply(bibs, f) ## 2018-10-08 ## TODO: this is risky but read.bib, bibentry, toRd and similar seem to work ## internally with UTF-8 ## ## if(!all(Encoding(res) == "UTF-8")){ ## # warning(paste("encoding is: ", paste0(Encoding(res), collapse = ", "), "\n")) ## Encoding(res) <- "UTF-8" ## } res } set_Rdpack_bibstyle <- local({ ## from /tools/R/bibstyle.R makeJSS() collapse <- function(strings) paste(strings, collapse="\n") emph <- function(s) if (length(s)) paste0("\\emph{", collapse(s), "}") authorList <- function (paper) { names <- sapply(paper$author, shortName) if (length(names) > 1L) result <- paste(names, collapse = ", ") else result <- names result } editorList <- function (paper) { names <- sapply(paper$editor, shortName) if (length(names) > 1L) result <- paste(paste(names, collapse = ", "), "(eds.)") else if (length(names)) result <- paste(names, "(ed.)") else result <- NULL result } shortName <- function (person) { if (length(person$family)) { result <- cleanupLatex(person$family) if (length(person$given)) paste(result, paste(substr(sapply(person$given, cleanupLatex), 1, 1), collapse = "")) else result } else paste(cleanupLatex(person$given), collapse = " ") } ## Clean up LaTeX accents and braces ## this is a copy of unexported tools:::cleanupLatex by Duncan Murdoch. cleanupLatex <- function(x) { if (!length(x)) return(x) latex <- tryCatch(tools::parseLatex(x), error = function(e)e) if (inherits(latex, "error")) { x } else { deparseLatexToRd(latexToUtf8(latex), dropBraces=TRUE) } } ## modified from tools::makeJSS() ## TODO: report on R-devel?. bookVolume <- function(book) { result <- "" if (length(book$volume)){ result <- paste("volume", collapse(book$volume)) if (length(book$number)) result <- paste0(result, "(", collapse(book$number), ")") if (length(book$series)) result <- paste(result, "of", emph(collapse(book$series))) }else if (length(book$number)){ ## todo: in JSS style and others the title end with '.' and ## 'number' is 'Number', but don't want to fiddle with this now. result <- paste(result, "number", collapse(book$number)) if (length(book$series)) result <- paste(result, "in", collapse(book$series)) }else if (length(book$series)) result <- paste(result, collapse(book$series)) if (nzchar(result)) result } ## new 2021-04-23 sortKeys <- function (bib) { result <- character(length(bib)) for (i in seq_along(bib)) { authors <- authorList(bib[[i]]) if (!length(authors)) authors <- editorList(bib[[i]]) if (!length(authors)) authors <- "" year <- collapse(bib[[i]]$year) authyear <- if(authors != "" ) paste0(authors, ", ", year) else year result[i] <- authyear } result } function(bibstyle = "JSSRd"){ switch(bibstyle, "JSSRd" = tools::bibstyle("JSSRd", .init = TRUE, .default = FALSE, cleanupLatex = cleanupLatex, bookVolume = bookVolume, sortKeys = sortKeys ), "JSSLongNames" = tools::bibstyle("JSSLongNames", .init = TRUE, .default = FALSE, cleanupLatex = cleanupLatex, bookVolume = bookVolume, sortKeys = sortKeys, shortName = function(person) { paste(paste(cleanupLatex(person$given), collapse=" "), cleanupLatex(person$family), sep = " ") } ), ## default stop("Unknown bibstyle ", bibstyle) ) } }) .onLoad <- function(lib, pkg){ ## define the styles but not set any of them as default set_Rdpack_bibstyle("JSSRd") set_Rdpack_bibstyle("JSSLongNames") ## set "LongNames" style for this package (Rdpack) Rdpack_bibstyles(package = pkg, authors = "LongNames") invisible(NULL) } Rdpack/R/promptSexpr.R0000644000175000017500000000660213501141722014477 0ustar nileshnilesh # like promptPackage but uses \Sexpr{} for automatic information updating promptPackageSexpr <- function(package, filename= NULL, final = TRUE, overview = FALSE, bib = TRUE){ # 2013-03-30 neew arg. `bib' paste0 <- function(...) paste(..., sep="") overv <- if(overview | !final) "" else "% " hide <- "\\Sexpr[stage=build,results=hide]" pd <- paste0("{pd <- packageDescription(\"", package, "\")}") lb <- paste0("{lb <- library(help=\"", package, "\", character.only=TRUE)}") lbflag <- "lbflag <- !is.null(lb$info[[2]])" Rdtxt <- list( paste0("\\name{", package, "-package}") , paste0("\\alias{", package, "-package}") , paste0("\\alias{", package, "}") , paste0("\\docType{", "package", "}") , "\\title{" , paste0(" ", hide, c(pd, lb)) # init. commands, cannot be outside sections. , " \\Sexpr[stage=build]{pd$Title}" , "}" , "\\description{" , " \\Sexpr[stage=build]{pd$Description}" , "}" , "\\details{" , " \\tabular{ll}{" , " Package: \\tab \\Sexpr[stage=build]{pd$Package}\\cr" , " Type: \\tab \\Sexpr[stage=build]{pd$Type}\\cr" , " Version: \\tab \\Sexpr[stage=build]{pd$Version} \\cr" , " Date: \\tab \\Sexpr[stage=build]{pd$Date}\\cr" , " License: \\tab \\Sexpr[stage=build]{pd$License}\\cr" , " LazyLoad: \\tab \\Sexpr[stage=build]{pd$LazyLoad}\\cr" , " Built: \\tab \\Sexpr[stage=build]{pd$Built}\\cr" , " }" , "" , " Index:" , paste0(" \\Sexpr[stage=build,results=rd]{paste(\"\\\\\\\\preformatted{\"" , ", paste(if(!is.null(lb$info[[2]])) lb$info[[2]] else \"No entries\",collapse=\"\\n\"), \"}\", sep=\"\")}") , "" , paste0(overv, c("~~ An overview of how to use the package, including the most important ~~" , "~~ functions ~~")) , "}" , "\\author{" , " \\Sexpr[stage=build]{pd$Author}" , "" , paste0("Maintainer: ", "\\Sexpr[stage=build]{pd$Maintainer}") , "}" , "\\references{" , if(bib) "% bibentry:all" else "% ~~ Literature or other references for background information ~~" , "}" , "% ~~ Optionally other standard keywords, one per line, from file KEYWORDS in ~~" , "% ~~ the R documentation directory ~~" , "\\keyword{ package }" , "% \\seealso{" , "% ~~ Optional links to other man pages, e.g. ~~" , "% ~~ \\code{\\link[:-package]{}} ~~" , "% }" , "% \\examples{" , "% ~~ simple examples of the most important functions ~~" , "% }" ) if(is.null(filename)) filename <- paste0(package, "-package.Rd") if(is.na(filename)) return(Rdtxt) cat(unlist(Rdtxt), file = filename, sep = "\n") message(gettextf("Created file named %s.", sQuote(filename)), "\n", gettext("Edit the file and move it to the appropriate directory."), domain = NA) invisible(filename) } Rdpack/R/RStudio.R0000644000175000017500000000321613501141722013523 0ustar nileshnilesh# In RStudio, call reprompt on function that cursor is pointing to. RStudio_reprompt <- function(verbose = TRUE) { if (!requireNamespace("rstudioapi") || !requireNamespace("rprojroot")) stop("RStudio support requires you to install the 'rprojroot' and 'rstudioapi' packages") sourceContext <- rstudioapi::getSourceEditorContext() infile <- sourceContext$path if (grepl("[.][rR]d$", infile)) # editing a help file reprompt(infile = infile, filename = infile, verbose = verbose) else if (grepl("[.][rRsSq]$", infile)) { # editing R source pkgdir <- rprojroot::find_package_root_file(path = dirname(infile)) pkg <- basename(pkgdir) if (length(sourceContext$selection) == 1) { fnname <- sourceContext$selection[[1]]$text } else fnname <- "" if (!nchar(fnname)) stop("Select a function name") if (!exists(fnname)) stop("Object ", sQuote(fnname), " not found. Run 'Install and Restart'?") existing <- help(fnname) # Subset to the ones in the current package existing <- existing[basename(dirname(dirname(existing))) == pkg] if (length(existing) == 1) { infile <- file.path(pkgdir, "man", paste0(basename(existing), ".Rd")) reprompt(infile = infile, filename = infile, verbose = verbose) } else if (!length(existing)) infile <- reprompt(fnname, filename = file.path(pkgdir, "man", paste0(fnname, ".Rd")), verbose = verbose) else stop("Multiple matches to ", sQuote(fnname), ". Open one help file manually.") } else stop("This tool only works on .Rd or .R files.") rstudioapi::navigateToFile(infile) }Rdpack/R/alias.R0000644000175000017500000000176213501141722013227 0ustar nileshnilesh # todo: are aliases updated for classes? update_aliases_tmp <- function(rdo, package = NULL){#only for methods, currently; only appends fname <- .get.name_content(rdo)$short # name of the generic rdoaliases <- toolsdotdotdot.Rd_get_metadata(rdo, "alias") # aliases currently in rdo curtxt <- get_sig_text(rdo, package = package) # process signatures described in rdo ucur <- parse_usage_text(curtxt) methaliases <- sapply(ucur, function(x) .methsig2alias(fname, x$defaults)) new_aliases <- methaliases[ !(methaliases %in% rdoaliases) ] if(length(new_aliases) > 0) # update the aliases for(alias in new_aliases){ rdo <- Rdo_insert(rdo, char2Rdpiece(alias, "alias")) } rdo } .methsig2alias <- function(name, sig){ res <- gsub("\"", "", paste(c(name, sig), collapse=",")) paste(res, "-method", sep="") # no comma after the last arg } Rdpack/R/runexamples.R0000644000175000017500000001536214041215301014475 0ustar nileshnilesh .comment <- function(x){ x invisible(NULL) } ## see also > utils::example run_examples <- function(excontent, # package = NULL, lib.loc = NULL, character.only = FALSE, give.lines = FALSE, local, # in utils::example() it is: local = FALSE, echo = TRUE, verbose = getOption("verbose"), setRNG = FALSE, ask = FALSE, # in utils::example() it is: getOption("example.ask"), ## prompt.prefix = "Rdpack" # in utils::example() it is: abbreviate(topic, 6), prompt.echo = "Rdpack> ", continue.echo = prompt.echo, run.dontrun = FALSE, run.donttest = FALSE, # in utils::example() it is: interactive() Rdsection = "examples", escape = TRUE ){ ## set the environment where source() evaluates the code; ## 2018-08-13 todo: it is not clear if this is the best choice; ## maybe could pass an environment from the macro \printExample, similarly ## to the citation macros (but first need to check if the cause is the choice ## made here: if(missing(local)) local <- parent.frame() # dontshow <- function(x){ # x # } # saveRDS(excontent, "excontent.RDS") excontent <- deparse(excontent) excontent <- gsub("^[ ]*\\{", "", excontent) excontent <- gsub("\\}[ ]*$", "", excontent) excontent <- gsub(paste0("^[ ]*", ".comment", "[ ]*\\(\"(.*)\"\\)[ ]*$"), "\\1", excontent) ## if(interactive()) ## browser() # file <- tempfile(fileext = ".Rd") tf <- tempfile("Rex") ## tools::Rd2ex(.getHelpFile(file), tf, commentDontrun = !run.dontrun, ## commentDonttest = !run.donttest) writeLines(excontent, tf) ## if (!file.exists(tf)) { ## if (give.lines) ## return(character()) ## warning(gettextf("%s has a help file but no examples", ## sQuote(topic)), domain = NA) ## return(invisible()) ## } on.exit(unlink(tf)) ## if (give.lines) ## return(readLines(tf)) ## if (pkgname != "base") ## library(pkgname, lib.loc = lib, character.only = TRUE) if (!is.logical(setRNG) || setRNG) { if ((exists(".Random.seed", envir = .GlobalEnv))) { oldSeed <- get(".Random.seed", envir = .GlobalEnv) on.exit(assign(".Random.seed", oldSeed, envir = .GlobalEnv), add = TRUE) } else { oldRNG <- RNGkind() on.exit(RNGkind(oldRNG[1L], oldRNG[2L]), add = TRUE) } if (is.logical(setRNG)) { RNGkind("default", "default") set.seed(1) } else eval(setRNG) } zz <- readLines(tf, n = 1L) skips <- 0L ## if (echo) { ## zcon <- file(tf, open = "rt") ## while (length(zz) && !length(grep("^### \\*\\*", zz))) { ## skips <- skips + 1L ## zz <- readLines(zcon, n = 1L) ## } ## close(zcon) ## } if (ask == "default") ask <- echo && grDevices::dev.interactive(orNone = TRUE) if (ask) { if (.Device != "null device") { oldask <- grDevices::devAskNewPage(ask = TRUE) if (!oldask) on.exit(grDevices::devAskNewPage(oldask), add = TRUE) } op <- options(device.ask.default = TRUE) on.exit(options(op), add = TRUE) } ## TODO: argument 'spaced' (and maybe others?) were introduced in R-3.4.0. wrk <- capture.output( if(getRversion() >= '3.4.0') source(tf, local, echo = echo, prompt.echo = prompt.echo, # paste0(prompt.prefix, getOption("prompt")), continue.echo = continue.echo, # paste0(prompt.prefix, getOption("continue")), spaced = FALSE, # do not print empty line before each source line verbose = verbose, max.deparse.length = Inf, encoding = "UTF-8", skip.echo = skips, keep.source = TRUE) else source(tf, local, echo = echo, prompt.echo = prompt.echo, # paste0(prompt.prefix, getOption("prompt")), continue.echo = continue.echo, # paste0(prompt.prefix, getOption("continue")), # spaced = FALSE, - no such argument before R-3.4.0 verbose = verbose, max.deparse.length = Inf, encoding = "UTF-8", skip.echo = skips, keep.source = TRUE) ) # \Sexpr[stage=build,results=rd]{ # paste0("\\\\examples{", { # pf <- "Rdpack" # tmp <- capture.output(utils::example("ES", prompt.prefix = pf)) # flags <- grepl("Rdpack> ", tmp) # tmp[!flags] <- paste0("#> ", tmp[!flags]) # tmp <- gsub("Rdpack> ", "", tmp) # res <- paste0(tmp, collapse = "\n") # }, "}", collapse = "\n")} # browser() flags <- grepl(paste0("^", prompt.echo), wrk) outflags <- !flags & !grepl("^[ ]*$", wrk) wrk[outflags] <- paste0("##: ", wrk[outflags]) wrk <- gsub(paste0("^", prompt.echo, "[ ]*"), "", wrk) ## wrk <- gsub(paste0("^[ ]*", "identity", "[ ]*\\(\"(.*)\"\\)[ ]*$"), "\\1", wrk) wrk <- gsub("^## *$", "", wrk) res <- paste0(paste0(wrk, collapse = "\n"), "\n") if(escape) # 2018-08-25 res <- .bspercent(res) ## TODO: prefix with spaces to indent from surrounding text? if(is.character(Rdsection)){ res <- paste0("\\", Rdsection, "{", res, "}\n") } # if(interactive()) # browser() res } ## cat(Rdpack:::run_examples(quote({2+2 ## ## trig ## sin(pi)}))) ## ## withAutoprint(quote({2+2 ## ## trig ## sin(pi)})) ## ## e1 <- ## (quote({2+2 ## ## trig ## sin(pi)})) ## ## attr(e1, "wholeSrcref") ## ## ## e2 <- ## quote({2+2 ## ## trig ## sin(pi)}) ## ## attr(e2, "wholeSrcref") ## ## e2a <- ## quote({2+2 ## sin(pi)}) ## ## attr(e2a, "wholeSrcref") ## ## unclass(attr(e2a, "wholeSrcref")) ## ## e3 <- ## quote(2+2) ## ## attr(e3, "wholeSrcref") ## Rdpack:::run_examples(quote({cvar::VaR(qnorm, x = c(0.01, 0.05), dist.type = "qf"); 2*3; 2 + 2; a <- 2 - 2; b <- 2/3 })) insert_fig <- function(file, package, code, insert = TRUE){ dirs <- c("./man/", file.path(".", package, "man")) w <- sapply(dirs, dir.exists) dcur <- dirs[w] figpath <- file.path(dcur, "figures") if(!dir.exists(figpath)) dir.create(figpath) grDevices::png(file.path(figpath, file)) ## plot(cars) force(code) grDevices::dev.off() if(insert) paste0("\\figure{", file, "}") else file } Rdpack/R/utils.R0000644000175000017500000002166013501141722013275 0ustar nileshnilesh.tag_in <- function(x, tags){ a <- attr(x,"Rd_tag") is.character(a) && length(a) == 1 && a %in% tags } .tag_eq <- function(x, tag){ a <- attr(x,"Rd_tag") is.character(a) && length(a) == 1 && a == tag } .ocompare <- function(x,y){ # outer compare f <- function(z) sapply(x, function(w) identical(z,w)) sapply(y,f) } .asym_compare <- function(x,y){ cmp <- .ocompare(x,y) if(length(x) == 1){ # 2012-10-03 added this if cmp <- matrix(cmp, nrow=1) } if(length(x) == 0){ inew <- seq_along(y) irem <- icom <- integer(0) }else if(length(y) == 0){ irem <- seq_along(x) inew <- icom <- integer(0) }else{ inew <- which( ! apply(cmp, 2, any) ) # in y but not in x irem <- which( ! apply(cmp, 1, any) ) # in x but not in y icom <- which( !(seq_along(x) %in% c(inew, irem)) ) # in both, x and y } list( i_new = inew, i_removed = irem, i_common = icom ) } rattr <- function(x,y){ # restore attributes, see Rdapply below if(is.list(x)){ if(!identical(attributes(x), attributes(y))) attributes(x) <- attributes(y) for(i in seq_along(x)) x[[i]] <- Recall(x[[i]], y[[i]]) } x } Rdapply <- function(x, ...){ # needed since rapply loses attributes of x wrk <- rapply(x, ...) rattr(wrk, x) } .pos_in_eqnpos <- function(verb, eqn){ # not a complete solution f <- function(x,y) length(x) > length(y) && all( x[seq_along(y)] == y ) flag <- FALSE res <- vector(mode="logical", length = length(verb)) for(i in seq_along(verb)){ for(j in seq_along(eqn)){ flag <- f(verb[[i]], eqn[[j]]) if(flag) break } res[i] <- flag } res } # 2012-09-08 new Rdtagapply <- function(object, FUN, rdtag, classes = "character", how = "replace", ...){ if(rdtag %in% c("mathVERB", "nonmathVERB", "nonmath")){ # special care for \eqn and \deqn feqnpos <- function(x) .tag_in(x, c("\\eqn", "\\deqn")) eqnpos <- Rdo_locate(object, feqnpos, lists = TRUE) eqnpos <- lapply(eqnpos, function(x) c(x,1)) # 1st arg. of \eqn or \deqn if(rdtag == "nonmath"){ anypos <- Rdo_locate_leaves(object) pos <- anypos[ !.pos_in_eqnpos(anypos, eqnpos) ] }else{ # is it better to use Rdo_locate_leaves here? fverbpos <- function(x) .tag_eq(x, "VERB") verbpos <- Rdo_locate(object, fverbpos, lists = FALSE) pos <- if(rdtag == "mathVERB") # verbpos[ verbpos %in% eqnpos ] verbpos[ .pos_in_eqnpos(verbpos, eqnpos) ] else # (rdtag == "nonmathVERB") # verbpos[ !( verbpos %in% eqnpos) ] verbpos[ !.pos_in_eqnpos(verbpos, eqnpos) ] } for(ind in pos) object[[ind]] <- FUN(object[[ind]], ...) object }else{ locfun <- function(x,...) if(.tag_eq(x, rdtag)) FUN(x,...) else x Rdapply(object,locfun, classes = classes, how = how, ...) } } .aux_Rdo_locate_leaves <- function(x, i){ if(is.logical(x)){ if(isTRUE(x)) i else FALSE }else{ # here x is a list of integer vectors lapply(x, function(x){ c(i,x)}) } } # inn1 <- parse_Rd("inner-methods.Rd") # Rdo_locate_leaves(inn1, function(x) grepl("^signature\\(", x)) Rdo_locate_leaves <- function(object, f = function(x) TRUE){ fxx <- function(x){ if(is.character(x)){ return(f(x)) # evaluate `f' for this leaf }else if(is.list(x)){ if(length(x)==0) # list() return(x) wrk <- lapply(x, fxx) for(i in seq_along(wrk)) wrk[[i]] <- .aux_Rdo_locate_leaves(wrk[[i]], i) indx <- sapply(wrk, function(y) !identical(y,FALSE) ) wrk <- wrk[indx] wrk <- do.call("c",wrk) return(wrk) }else{ return(FALSE) # todo: replace this with a function and additional argument } } fxx(object) } .merge_pos0 <- function(a, b){ # 2012-09-25 new if(is.numeric(b)) c(a,b) else if(is.list(b)){ res <- vector(mode="list", length=length(b)) for(i in seq_along(b)){ res[[i]] <- Recall(a, b[[i]]) } res }else if(is.logical(b)){ if(isTRUE(b)) a else as.numeric(NA) # numeric(0) }else{ attr(a, "merge_tag") <- b # obache tozi tag se gubi po-kasno a } } .merge_pos <- function(a, b, ...){ # 2012-09-25 new if(is.numeric(a) && length(a)==1){ a <- as.list(1:a) # todo: process the case a=0 } wrk <- list() for(i in a){ wrk <- c(wrk, .merge_pos0(a[[i]], b[[i]]) ) } res <- wrk len <- sapply(res, length) res <- res[len>0] # drop zero length values drop <- sapply(res, function(x) any(is.na(x))) res[ !drop] } .notFALSE <- function(x) !identical(x, FALSE) .notTRUE <- function(x) !isTRUE(x) # !identical(x, TRUE) # 2012-10-20 dobavyam argument nested # 2012-10-07 dobavyam argument fpos Rdo_locate <- function(object, f = function(x) TRUE, pos_only = TRUE, lists = FALSE, fpos = NULL, nested = TRUE){ fxx <- function(x){ if(is.character(x)){ # a leaf, evaluate `f' for it f(x) }else if(is.list(x)){ fli <- if(lists) f(x) else FALSE if(!nested && fli) return(TRUE) wrk <- if(fli) list(fli) else list() if(length(x)>0) wrk <- c(wrk, .merge_pos(length(x), lapply(x, fxx)) ) # recurse wrk }else{ # this should not happen for Rd objects FALSE # todo: replace this with a function and additional argument? } } pos <- fxx(object) f <- if(is.function(fpos)) function(x) list(pos = x, value = fpos(object, x)) else if(isTRUE(pos_only)) NULL else if(is.function(pos_only)) function(x) list(pos = x, value = pos_only(object[[x]])) else function(x) list(pos = x, value = object[[x]]) if(!is.null(f)) lapply(pos, f) else pos } # insert sep between successive elements of x .Rdinter <- function(x, sep = Rdo_newline(), before_first = FALSE, after_last = FALSE){ indx <- c(rbind(seq_along(x), length(x) + 1)) if(before_first) indx <- c( length(x) + 1, indx) if(!after_last) indx <- head(indx,-1) c(x, list(sep))[indx] } .Rd_tidy <- function(rdo){ # todo: optionally remove empty sections? tags <- Rdo_tags(rdo) # todo: remove multiple empty lines? secpos <- which(tags != "TEXT") # remove empty lines at top level? secpos <- secpos[secpos > 1] if(length(secpos)==0) return(rdo) nl <- Rdo_newline() nlpos <- integer(0) for(i in secpos){ # 2012-09-20 smenyam (!identical(rdo[[i-1]], nl)) s dolnoto. if(!Rdo_is_newline(rdo[[i-1]])) # inache tryabva da se grizha za "srcref" attribute nlpos <- c(nlpos, i) } if(length(nlpos)==0) return(rdo) # todo: this is lazy for(i in sort(nlpos, TRUE)){ # sort in decreasing order, otherwise indices change rdo <- Rdo_insert_element(rdo, nl, i) } rdo } Rdo_remove_srcref <- function(rdo){ f <- function(x){ a <- attributes(x) if(is.list(x)){ x <- lapply(x,f) if(!is.null(a)) # 2012-10-07 check for NULL attributes(x) <- a } if(!is.null(attr(x,"srcref"))) attr(x,"srcref") <- NULL x } f(rdo) } Rd_combo <- function(rd, f, ..., .MORE){ # todo: allow a directory? dots <- list(...) flag <- missing(.MORE) locfun <- function(x){ locwrk <- permissive_parse_Rd(x) locargs <- c(list(locwrk), dots) locres <- try( do.call(f, locargs), silent=TRUE) if(flag || inherits(locres,"try-error")) locres else{ try( do.call(.MORE, list(locres)), silent=TRUE) } } lapply(rd, locfun) } Rdpack/R/usage.R0000644000175000017500000004642613501141722013250 0ustar nileshnileshinspect_usage <- function(rdo){ ut <- get_usage_text(rdo) if(grepl("=[ ]*[,)]", ut)){ # TODO: this is a patch; should be sorted out properly! cat("Encountered formal arguments in the form 'arg ='\n") cat("\twithout righ-hand side, dropping the equal sign to proceed.\n") ut <- gsub("=[ ]*([,)])", "\\1", ut) } urdo <- parse_usage_text(ut) ucur <- lapply(seq_along(urdo), function(x) get_usage(name = urdo[[x]]$name, S3class = urdo[[x]]$S3class, S4sig = urdo[[x]]$S4sig, infix = urdo[[x]]$infix, fu = urdo[[x]]$fu, out.format="list")) mapply(compare_usage1, urdo, ucur, SIMPLIFY=FALSE)# ucur is of the same length as urdo but } # it may contain NULLs in some positions inspect_args <- function(rdo, i_usage){ argnames_rdo <- Rdo_get_argument_names(rdo) # TODO: this is for testing! # stopifnot(all( tools:::.Rd_get_argument_names(rdo) == # Rdo_get_argument_names(rdo) )) if(missing(i_usage)) i_usage <- inspect_usage(rdo) argnames_cur <- unique(unlist(lapply(i_usage, function(x) attr(x,"details")$cur_usage$argnames))) ## 2018-01-31 in case argnames_cur is NULL, ## since sort used on NULL inside identical() gives warning. if(length(argnames_cur) == 0) argnames_cur <- character(0) structure(identical(sort(argnames_rdo), sort(argnames_cur)), details = list( rdo_argnames = argnames_rdo , cur_argnames = argnames_cur , added_argnames = argnames_cur[!(argnames_cur %in% argnames_rdo)] , removed_argnames = argnames_rdo[!(argnames_rdo %in% argnames_cur)] )) } # new 2012-09-22 parse_text <- function(text, ..., keep = TRUE){ # see comments in parse_usage_text ks <- options("keep.source") if(identical(keep, ks)){ # comment on 2014-03-28 : this condition will never be TRUE # since ks is named! res <- parse(text=text, ...) }else{ options(keep.source = keep) res <- parse(text=text, ...) options(ks) # restore previous value } res } parse_usage_text <- function(text){ text <- gsub("\\\\dots", "...", text) # deal with \dots # deal with \method and \S3method macros for desciption of S3 methods. text <- gsub("\\\\(S3)?method\\{([^}]*)\\}\\{([^}]*)\\}", "S3_usage(\\2,\\3)", text) # todo: tova sa krapki za S3 metodi. Need to pass # syntactically correct text to parse below. text <- gsub("S3_usage\\((\\[+),", "S3_usage(`\\1`,", text) # [, [[ text <- gsub("S3_usage\\((\\$+),", "S3_usage(`\\1`,", text) # $ if(any(grepl("S3_usage\\([^,]*,function[ ]*\\)", text))){ # 2012-10-12 dobavyam "any" fun_flag <- TRUE text <- gsub("(S3_usage\\([^,]*,)function[ ]*\\)", "\\1fufufu_function)", text) }else fun_flag <- FALSE # deal with \S4method macro text <- gsub("\\\\S4method\\{([^}]*)\\}\\{([^}]*)\\}", "S4_usage(\\1,\\2)", text) # parse_text ensures that the srcref attribute will be set. # parse() normally does that but 'R CMD check' for example sets tmp <- parse_text(text) # keep.source to FALSE, leading to errors in the examples. # todo: check for errors after parse() # a character vector with one element for each usage expression in text usages <- sapply(attr(tmp, "srcref"), function(x) paste(as.character(x), sep="\n", collapse="\n")) if(fun_flag) usages <- gsub("fufufu_function", "function", usages) lapply(usages, parse_1usage_text) } # TODO: x %% y i podobni tyabva da se opravyat! vzh Arithmetic.Rd ot base parse_1usage_text <- function(text){ # modify usage texts to become function bodies embedded in calls to formals() f <- function(x) paste0(sub("^[^(]+\\(", "formals(function(", x), " NULL )") fu <- TRUE # in most cases we are dealing with functions if(grepl("^[[:alpha:]._][[:alnum:]._]*$", text)){ # a variable, not function call fu <- FALSE name <- text S3class <- "" S4sig = "" infix <- FALSE res <- NULL }else if(grepl("^S3_usage",text)){ S3class <- gsub("[^,]*,([^)]*)\\).*", "\\1", text) # patch, undo the quotes maybe put by parse_usage_text text <- gsub("S3_usage\\([`\"']([^,`]+)[`\"']", "S3_usage(\\1", text) name <- gsub("[^(]*\\(([^,]*),.*", "\\1", text) if(grepl("S3_usage\\(.*\\)[ ]* <-[ ]*value[ ]*$", text)){ # S3 assignment method text <- gsub("(S3_usage\\()([^,]*)(.*)\\)[ ]* <-[ ]*value[ ]*$", "\\1`\\2<-`\\3,value)", text) name <- paste0(name, "<-") }else if(!grepl("^[[:alpha:]._:][[:alnum:]._:]+$", name)){ # non-syntactic name text <- gsub("S3_usage\\(([^,]*,)", "S3_usage(`\\1`,", text) } text <- gsub("[^)]*\\)(.*)", paste(name, ".", S3class, "\\1", sep=""), text) S4sig = "" infix <- FALSE wrk <- f(text) res <- eval(parse(text = wrk)) }else if(grepl("^S4_usage",text)){ name <- gsub("[^(]*\\(([^,]*),.*", "\\1", text) # same as for S3 name above S3class <- "" #browser() # similar to S3 but there may be commas in the signature, so change accordingly if(grepl("S4_usage\\(.*\\)[ ]* <-[ ]*value[ ]*$", text)){ # S4 assignment method text <- gsub("(S4_usage\\()([^,]*)(.*)\\)[ ]* <-[ ]*value[ ]*$", "\\1`\\2<-`\\3,value)", text) if(grepl("\\([ ]*,[ ]*value", text)) # patch for 0 arguments in the current signature text <- sub("\\([ ]*,[ ]*value", "(dummyvar, value", text) name <- paste0(name, "<-") }# TODO: non-syntactic names? S4sig <- gsub("[^,]*,([^)]*)\\).*", "\\1", text) # same as for S3class above # but S4 signatures may have more than 1 element, # make a character vector from the single string s <- paste("names(formals(function(", S4sig, ") NULL))", sep="") S4sig <- eval(parse(text = s)) text <- gsub("[^)]*\\)(.*)", paste0(name, "\\1"), text) infix <- FALSE wrk <- f(text) res <- eval(parse(text = wrk)) }else{ # extract the function names from `usages' S3class <- "" S4sig = "" e <- parse(text = text) name <- as.character(e[[1]][[1]]) # !grepl( paste0("^",name)) - s regexp tryabva da se vnimava # ponezhe ako name e "+", tova e drugo. # ne mozhe i fixed = TRUE, ponezhe iskam da match-na ot nachaloto infix <- !(substr(text,1,nchar(name)) == name) ec <- lapply(1:length(e[[1]]), function(x) as.character(e[[1]][[x]])) res <- NULL if(name == "<-"){ # todo: more care needed here e2 <- e[[1]][[2]] if(is.call(e2)){ e2_named <- .make_named(e2) name <- paste0(e2[[1]], "<-") wrk <- paste0("formals(function(", paste(e2_named[-1], collapse=","), ",", e[[1]][[3]], # rhs (i.e., value) should have 1 elem only ") NULL )" ) }else{ # simple assignment (todo: can it be anything else here?) wrk <- paste0("formals(function(", paste(ec[-1], collapse=","), ") NULL )" ) } }else if(name == "!"){ wrk <- sub("!", "", text) wrk <- paste0("formals(function(", wrk, ") NULL)") }else if(name == ":"){ wrk <- "formals(function(from,to) NULL)" }else if(name %in% c("if", "for", "while", "repeat", "break", "next")){ # control res <- as.character(sapply(e[[1]], identity)) }else if(infix){ e <- parse(text = paste0("quote(",text,")")) ec <- .make_named(lapply(e[[1]][[2]], identity)) wrk <- paste0("formals(function(", paste(ec[-1], collapse=","), ") NULL )" ) }else{ wrk <- f(text) } if(is.null(res)) res <- eval(parse(text = wrk)) } pairlist2f_usage1(res, name, S3class, S4sig, infix, fu) # convert pairlists obtained from } # `formals()' into named "f_usage" objects. .make_named <- function(v, sep = " = "){ if(length(v) == 0) return(character(0)) nams <- allNames(v) wrk <- sapply(seq_along(v), function(x) if(nams[x]=="") paste(v[x]) else paste(nams[x], v[x], sep=sep)) wrk } # generate f_usage object for a function (needs clean up) # todo: argument `...' not used? get_usage <- function(object, name = NULL, force.function = FALSE, ..., S3class = "", S4sig = "", infix = FALSE, fu = TRUE, out.format = "text"){ if (missing(name)) # based on a chunk from utils::prompt if (is.character(object)){ name <- object object <- NULL }else { name <- substitute(object) if (is.name(name)) name <- as.character(name) else if (is.call(name) && (as.character(name[[1L]]) %in% c("::", ":::", "getAnywhere"))) { name <- as.character(name) name <- name[length(name)] } else stop("cannot determine a usable name") } # get(name, envir = asNamespace("mixAR")) # do.call(getAnywhere,list(x)) x <- if(!missing(object) && !is.null(object)) object else if(!fu){ x0 <- try(get(name), silent=TRUE) if(inherits(x0,"try-error")){ spec_values <- c("NULL", "TRUE", "FALSE", "NA", sapply(c(Inf, NaN, -Inf), as.character)) if(name %in% spec_values) x0 <- spec_values[ name == spec_values ][1] else x0 <- NULL } "OK: variable" # this value is not used further, it must not be NULL though }else if(!identical(S3class, "")){ # 2012-10-16 dobavyam getAnywhere, etc. x0 <- try(getS3method(name, S3class), silent=TRUE) if(inherits(x0,"try-error")){ x0 <- do.call(getAnywhere, list(paste0(name, ".", S3class))) if(length(x0$objs) > 0) x0$objs[[1]] else NULL }else x0 }else if(!identical(S4sig, "")) # todo: coordinate with the rest! getMethod(name, S4sig) # transform S4sig here if it is not convenient to # keep it ready for use entry in f_usage objects. else{ name0 <- if(grepl('^".*"$', name)) # non-syntactic name sub('^"(.*)"$', "\\1", name) else name x0 <- try(get(name0, envir = parent.frame()), silent=TRUE) if(inherits(x0,"try-error")){ x0 <- do.call(getAnywhere, list(name0)) if(length(x0$objs) > 0) # todo: needs more work here. IN particular, there x0$objs[[1]] # should be a package argument to avoid taking # blindly whatever comes up. else NULL }else x0 } if(is.null(x)) return(x) if (fu && !(is.function(x) || force.function)){ warning("The object is not a function.") # The return value may be appropriate return(name) # for data objects. # todo: Rethink! } argls <- if(fu){ if(!identical(S4sig, "")) S4formals(x) else if(!identical(S3class, "")) formals(x) else{ spec_args <- .special_args[name] if(is.na(spec_args)){ wrk <- formals(x) if(is.null(wrk)) # takes care for primitive functions, napr. seq.int wrk <- formals(args(x)) # argls will still be NULL if x is a function with no arguments. # Note that formals returns pairlist and the pairlist with # zero elements is NULL (unlike list()). Taka che # pairlist2f_usage() needs to know how to deal with this case. wrk }else eval(parse(text = paste0("formals(function(", spec_args, ") NULL)"))) } }else NULL # 2012-10-11 smenyam pairlist2f_usage na pairlist2f_usage1 res <- pairlist2f_usage1(argls, name, S3class = S3class, S4sig = S4sig, infix = infix, fu = fu) if(out.format != "list") res <- as.character(res) res } .special_args <- c("~" = "y, model", "@" = "object, name", "$" = "x, name", "||" = "x, y", "&&" = "x, y", "[" = "x, i, j, ..., drop = TRUE", "[[" = "x, i, j, ..., exact = TRUE", "@<-" = "object, name, value", # formals("@<-") actually works "$<-" = "x, name, value", "[<-" = "x, i, j, ..., value", "[[<-" = "x, i, value", ":" = "from, to" ) # the comparison is symmetric but the interpretation assumes that ucur may be more recent. compare_usage1 <- function(urdo, ucur){ # urdo - usage from Rdo file/object; # ucur - generated from actual object ## 2019-04-14 in R-devel for R-3.7.0 this gives error. ## What is the intent in is.na(ucur) and is.na(urdo)? The documentation of ## compare_usage1() clearly shows that the intent is that of gbutils::isNA(). I ## can't find now what may set ucur or urdo to NA, probably initially I was setting ## NA, not NULL, and the check is.na() remained as a guard, which is not needed ## now. ## ## For typical input here, is.na() gives something like: ## ## --- value of length: 7 type: logical --- ## name S3class S4sig infix fu argnames defaults ## FALSE FALSE FALSE FALSE FALSE FALSE FALSE ## ## TODO: check if it is necessary in the code below to be more defensive ## e.g. (urdo$S3class != "") is potentially troublesome. ## ## obj_removed <- is.null(ucur) || is.na(ucur) ## obj_added <- is.null(urdo) || is.na(urdo) obj_removed <- is.null(ucur) || ( is.atomic(ucur) && length(ucur) == 1 && is.na(ucur) ) obj_added <- is.null(urdo) || ( is.atomic(urdo) && length(urdo) == 1 && is.na(urdo) ) if(!obj_added && !obj_removed && urdo$S3class != ""){ fn <- paste(urdo$name, ".", urdo$S3class, sep="") if(ucur$name == fn){ ucur$name <- urdo$name ucur$S3class <- urdo$S3class } } status <- identical(urdo, ucur) alias <- if(obj_removed) "" else if(ucur$S3class != "") paste(ucur$name, ".", ucur$S3class, sep="") else if(!identical(ucur$S4sig, "")) paste0(ucur$name, ",", paste(ucur$S4sig, collapse=","), "-method") else ucur$name if(grepl('^".*"$', alias)){ # non-syntactic name, drop the quotes alias <- sub('^"(.*)"$', "\\1", alias) } if(obj_removed || obj_added) return( structure( status, details = list( obj_removed = obj_removed , obj_added = obj_added , rdo_usage = urdo , cur_usage = ucur , alias = alias )) ) identical_names <- urdo$name == ucur$name identical_argnames <- identical(urdo$argnames, ucur$argnames) identical_defaults <- identical(urdo$defaults, ucur$defaults) identical_formals <- identical_argnames & identical_defaults added_argnames <- ucur$argnames[ !(ucur$argnames %in% urdo$argnames) ] removed_argnames <- urdo$argnames[ !(urdo$argnames %in% ucur$argnames) ] # note: !!! intersect() is binary operation s <- intersect( intersect(names(urdo$argnames), names(ucur$argnames)), intersect(names(urdo$defaults), names(ucur$defaults)) ) unchanged_defaults <- urdo$defaults[ ucur$defaults[s] == urdo$defaults[s] ] names_unchanged_defaults <- names(unchanged_defaults)[unchanged_defaults] # todo: more details for the case when !identical, e.g. equal up to reordering, # added/removed defaults structure( status, details = list( identical_names = identical_names , obj_removed = obj_removed , obj_added = obj_added , identical_argnames = identical_argnames , identical_defaults = identical_defaults , identical_formals = identical_formals , added_argnames = added_argnames , removed_argnames = removed_argnames , names_unchanged_defaults = names_unchanged_defaults , rdo_usage = urdo , cur_usage = ucur , alias = alias )) } Rdpack/R/predefined.R0000644000175000017500000000670213501141722014242 0ustar nileshnilesh.rd_sections <- # note: user defined sections are typeset before note, seealso, examples. c("\\name", "\\Rdversion", "\\docType", "\\alias", "\\encoding", "\\concept", "\\title", "\\description", "\\usage", "\\format", "\\source", "\\arguments", "\\details", "\\value", "\\references", "\\section", "\\note", "\\author", "\\seealso", "\\examples", "\\keyword") ## todo: "\\Sexpr", "\\Rdopts", "\\newcommand", "\\renewcommand" rdo_top_tags <- unique(c(.rd_sections, "#ifdef", "#ifndef", "\\newcommand", "\\renewcommand", "COMMENT", "TEXT" )) Rdo_piece_types <- c( name = "VERB" # sections , alias = "VERB" , concept = "TEXT" , docType = "TEXT" , title = "TEXT" , description = "TEXT" , examples = "RCODE" , usage = "RCODE" , Rdversion = "VERB" , synopsis = "VERB" , Sexpr = "RCODE" , RdOpts = "VERB" , code = "RCODE" # macros , dontshow = "RCODE" , donttest = "RCODE" , testonly = "RCODE" , dontrun = "VERB" , env = "VERB" , kbd = "VERB" , option = "VERB" , out = "VERB" , preformatted = "VERB" , samp = "VERB" , special = "VERB" , url = "VERB" , verb = "VERB" , deqn = "VERB" , eqn = "VERB" , renewcommand = "VERB" , newcommand = "VERB" ) # todo: not complete. Skaniray instalirana # dokumentatsiya za tezi raboti! Rdo_predefined_sections <- c( name = "VERB" , alias = "VERB" , concept = "TEXT" , docType = "TEXT" , title = "TEXT" , description = "TEXT" , examples = "RCODE" , usage = "RCODE" , Rdversion = "VERB" , synopsis = "VERB" , section = "TEXT" # not clear what to put for this element # (and the following) 2012-09-23 new entries below. (maybe # their absence was the reason for some strange behaviour of # char2Rdpiece). Slagam vsichkite "TEXT", no (todo:) tryabva da # se proveri. , arguments = "TEXT" , keyword = "TEXT" , note = "TEXT" , format = "TEXT" , source = "TEXT" , details = "TEXT" , value = "TEXT" , references = "TEXT" , author = "TEXT" , seealso = "TEXT" ) Rdpack/R/yytransient.R0000644000175000017500000001026213501141722014522 0ustar nileshnilesh # 2013-12-01 new; need testing .ascharRd <- function(rdo){ if(is.character(rdo)) # note: applying as.character.Rd, as below gives error in this case res <- as.vector(rdo) # to drop attributes; else{ class(rdo) <- "Rd" res <- as.character(rdo) } paste(res, collapse="") # todo: argument to make this optional? } .safeRdtag <- function(x, nulltag = ""){ # replaces NULL with nulltag res <- attr(x, "Rd_tag") if(is.null(res)) res <- nulltag res } # a replacement for tools:RdTags; takes # 2013-12-08 renamed from .top_RdTags Rdo_tags <- function(rdo, nulltag = ""){ # note: absent Rd_tag's are returned as "" locf <- function(x) .safeRdtag(x, nulltag) res <- sapply(rdo, locf) if (length(res)==0) res <- character() res } Rdo_which <- function(rdo, fun){ # fun - predicate wrk <- sapply(rdo, fun) which(wrk) } # 2013-12-08 renamed from .whichtageq Rdo_which_tag_eq <- function(rdo, tag){ tags <- Rdo_tags(rdo) pos <- which(tags == tag) pos } # 2013-12-08 renamed from .whichtagin Rdo_which_tag_in <- function(rdo, tags){ # TODO: needs testing! alltags <- Rdo_tags(rdo) pos <- which(sapply(alltags, function(x) .tag_in(x,tags) )) pos } Rdo_get_item_labels <- function(rdo){ wrk <- Rdo_locate(rdo, f = function(x){ # attr(x,"Rd_tag") == "\\item" .tag_eq(x, "\\item") }, lists = TRUE, nested = FALSE, pos_only = function(x) if(length(x) > 0) .ascharRd(x[[1]]) else "" #in \itemize items do not have labels ) sapply(wrk, function(x) x$value) } Rdo_get_argument_names <- function(rdo){ # 2013-12-08 was: indx <- Rdo_locate_predefined_section(rdo, "\\arguments") # todo: shouldn't this be using some "locate"-type function? I removed # Rdo_locate_predefined_section() since it simply checks the tags as # below but probably should vreate a ne function based on a "locate" indx <- Rdo_which_tag_eq(rdo, "\\arguments") if(length(indx) == 0) return(character(0)) # no "arguments" section in rdo; initially was: NA_character_ txt <- Rdo_get_item_labels(rdo[[indx]]) if (length(txt)==0) # this chunk: copied from tools:::.Rd_get_argument_names return(character()) txt <- unlist(strsplit(txt, ", *")) txt <- gsub("\\\\l?dots", "...", txt) txt <- gsub("\\\\_", "_", txt) txt <- .strip_whitespace(txt) txt <- unique(txt) # cater for duplication due to #ifdef unix or windows; # see e.g. system.Rd or system2.Rd in base package # # todo: more thought on this? txt } # 2013-10-23 new # pattern = ".*[.]Rd$" would be too dangerous. # but may be exclude could exclude foo-package Rdreplace_section <- function(text, sec, pattern, path = "./man", exclude = NULL, ...){ rdnames <- dir(path, pattern, full.names=TRUE) # todo: allow 'exclude' to have length more than 1 if(!is.null(exclude)){ rdexcl <- dir(path, exclude, full.names=TRUE) rdnames <- setdiff(rdnames, rdexcl) } for(nam in rdnames){ try(Rdo_set_section(text, sec, nam)) } rdnames # todo: return a logical vector of success/failures? } Rdo_locate_core_section <- function(rdo, sec){ # 2013-12-08 # Rdo_which_tag_eq(rdo, sec) secall <- Rdo_sections(rdo) sec.names <- sapply(secall, function(x) x$title) indx <- which(sec.names == sec) if(length(indx)==0) list() else ## 2018-04-21 was: secall[[indx]] secall[indx] } Rdpack/R/manip.R0000644000175000017500000003215613501141722013243 0ustar nileshnilesh## Do not edit this file manually. ## It has been automatically generated from *.org sources. # generic rdo manipulation functions append_to_Rd_list <- function(rdo, x, pos){ # pos is a numeric vector rdo[[pos]] <- structure( c(rdo[[pos]], x), Rd_tag = attr(rdo[[pos]],"Rd_tag") ) rdo } # todo: allow vector `pos' to insert deeper into the object # todo: character `pos' to insert at a position specified by "tag" for example? Rdo_insert_element <- function(rdo, val, pos){ n <- length(rdo) if(missing(pos)) pos <- n+1 stopifnot(1 <= pos, pos <= n+1) res <- if(pos==1) c(list(val), rdo) else if(pos==n+1) c(rdo, list(val)) else c( rdo[1:(pos-1)], list(val), rdo[pos:n]) attributes(res) <- attributes(rdo) # todo: more guarded copying of attributes? res } Rdo_get_insert_pos <- function(rdo, tag){ tags <- Rdo_tags(rdo) pos <- which(tags == tag) pos <- if(length(pos)>0) max(pos) + 1 # put after the last occurence of the same section else if(tag %in% .rd_sections){ indx <- which(.rd_sections == tag) iafter <- which( tags %in% .rd_sections[-seq_len(indx)] ) iafter[1] # put in front of the next section in .rd_sections }else{ # otherwise put at the end of rdo length(rdo)+1 } pos } Rdo_insert <- function(rdo, val, newline = TRUE){ tag <- attr(val,"Rd_tag") if(is.null(tag)) stop("val has no Rd_tag attribute.") pos <- Rdo_get_insert_pos(rdo, tag) # 2013-03-29 - additional check for pos # todo: this is incomplete! if(newline && ( (length(pos) == 1 && pos <= length(rdo) && !Rdo_is_newline(rdo[[pos]])) || (length(pos) == 1 && pos > length(rdo)) || length(pos) > 1 # todo: this is incomplete ) ) rdo <- Rdo_insert_element(rdo, Rdo_newline(), pos) rdo <- Rdo_insert_element(rdo, val, pos) if(newline && pos > 1 && !Rdo_is_newline(rdo[[pos-1]])) rdo <- Rdo_insert_element(rdo, Rdo_newline(), pos) rdo } # this is not specific to "sections", any Rd_tag in 'val' will do Rdo_modify <- function(rdo, val, create=FALSE, replace=FALSE, top = TRUE){ sec <- attr(val,"Rd_tag") if(is.null(sec)) stop("val has no Rd_tag attribute.") rdotag <- attr(rdo,"Rd_tag") if(top && !is.null(rdotag) && rdotag == sec){ # rdo is the section `sec'; if(replace) # todo: character 'replace' not handled yet. # append to the end return(val) else{ rdo <- append_to_Rd_list( list(rdo), val, 1) return( rdo[[1]] ) } } pos <- Rdo_which_tag_eq(rdo, sec) if(length(pos)>0){ if(is.character(replace)){ # the value to replace goodpos <- sapply(pos, # todo: the check below is simplistic function(x){ locval <- rdo[[x]] is.list(locval) && length(locval) == 1 && locval[[1]] == replace }) goodpos <- pos[goodpos] if(length(goodpos) > 0) rdo[[ goodpos[1] ]] <- val else if(create) rdo <- Rdo_insert(rdo, val) }else if(replace) rdo[[ pos[1] ]] <- val # pos[1] in case there are more else rdo <- append_to_Rd_list(rdo, val, pos[1]) }else if(create) # argument section not present, create one rdo <- Rdo_insert(rdo, val) # rdo[[ length(rdo)+1 ]] <- val else stop("No section ", sec, " to replace or modify.") rdo } ## The 'locate_' family of functions finds (recursively) positions of elements of rdo objects. ## A position is a vector suitable for use in '[[' or a list of such vectors. # find the index the element enclosing rdo[[ind]] that has Rd_tag 'tag'. # (e.g. if rdo[[ind]] is an '\item', we may wish to grab the enclosing '\describe'.) .locate_enclosing_tag <- function(rdo, ind, tag, baseind = numeric(0), mindepth=0){ repeat{ fullind <- c(baseind,ind) rdtag <- if(length(fullind) > 0) attr(rdo[[fullind]], "Rd_tag") else attr(rdo , "Rd_tag") if(is.character(rdtag) && rdtag == tag) return(ind) else if(length(ind)==mindepth) return(as.numeric(NA)) ind <- head(ind,-1) # drop the last level } } ## The '_top_' family of functions look only at the top level of rdo, in the sense that they ## examine the elements of rdo at the top level and do not search recursively its structure. ## Some of these functions examine also rdo as a whole (todo: maybe all of them should do ## this for consistency). .locate_top_tag <- function(rdo, sec, tag = "\\describe"){ if(sec == ""){ # search at top level of rdo indx1 <- integer(0) }else{ indx1 <- .locate_sec_content(rdo, sec) if(sec %in% c("\\arguments", "\\value")) # these sections are themselves lists return(indx1) rdo <- rdo[[indx1]] } indx3 <- Rdo_which_tag_eq(rdo, tag) if(length(indx3)==0) return(integer(0)) indx3 <- indx3[[1]] # playing safe, in case more than one c(indx1,indx3) # todo: option to return a list of all matches? } .locate_top_items <- function(rdo, sec, labels=FALSE){ indx1 <- .locate_top_tag(rdo, sec) if(length(indx1) == 0) return(list()) indx2 <- Rdo_which_tag_eq(rdo[[indx1]], "\\item") res <- lapply( indx2, function(x) c(indx1, x)) # returns a list of positions # todo: item labels (i.e., the 1st arg. of \item) may be long, is this a problem? if(isTRUE(labels) || is.character(labels)) # set names attribute if requested names(res) <- sapply(res, function(x) .get_item_label(rdo,x) ) if(is.character(labels)) # take only the requested items res <- res[labels] res } .nl_and_indent <- function(rdo, newlines = TRUE, indent = " "){ nl <- Rdo_newline() tab <- indent # todo: allow it to be dropped wrk <- lapply(rdo, function(x) list(nl, tab, x) ) res <- do.call("c", wrk) # todo: is this the correct arrangement - ne, gubi Rd_tag attr(res, "Rd_tag") <- attr(rdo, "Rd_tag") # 2012-10-16 todo: "Rd" attribute? - use c_Rd? res } .get_subset <- function(rdo, pos, rdtag = FALSE, keep.class = FALSE, newlines = FALSE){ if(newlines){ nl <- Rdo_newline() wrk <- lapply(pos, function(x) list(nl, rdo[[x]]) ) res <- do.call("c", wrk) # todo: check if this is the correct arrangement }else res <- lapply(pos, function(x) rdo[[x]]) if(isTRUE(rdtag)) attr(res, "Rd_tag") <- attr(rdo, "Rd_tag") else if(is.character(rdtag)) attr(res, "Rd_tag") <- rdtag if(keep.class) class(res) <- class(rdo) res } .get_item_label <- function(rdo, pos){ # 2013-12-01 no need of looking for leaves after introducing .ascharRd() # indx <- c(pos, .locate_item_label(rdo, pos)) # res <- rdo[[indx]] indx <- c(pos, 1) res <- .ascharRd(rdo[[indx]]) res } # 'labels' is a logical or a character vector of labels .get_top_items <- function(rdo, sec, labels){ # e.g. sec = "Slots", "arguments" itemind <- .locate_top_items(rdo, sec, labels=labels) lapply(itemind, function(x) rdo[[ x ]] ) # see also .get_subset() } .get_top_labels <- function(rdo, sec){ indx <- .locate_top_items(rdo, sec) sapply(indx, function(x) .get_item_label(rdo,x)) } # manipulation of specific sections # todo: this is very similar to parse_Rdname # 2012-11-04 partly done, introduced function .parse_long_name() .get.name_content <- function(rdo){ # todo: error processing Rd section \name name <- rdo[[ Rdo_which_tag_eq(rdo, "\\name") ]] # 2012-11-04 # dropping "-methods" or similar, if present # short <- gsub("^([^-]+)-.*", "\\1", name) short <- .parse_long_name(name)["name"] c(name = name, short = short) } # Rd section \arguments Rdo_append_argument <- function(rdo, argname, description = NA, indent = " ", create=FALSE){ if(is.na(description)) description <- "~~ TODO: describe this argument. ~~" if(length(description) == 1 && length(argname) > 1) description <- rep(description, length(argname)) wrk1 <- lapply(1:length(argname), function(i) list(indent, Rdo_item(argname[i], description[i]), Rdo_newline()) ) wrk <- Rdo_macro( do.call("c", wrk1), "\\arguments") Rdo_modify(rdo, wrk, create=TRUE) } # Rd section \usage # todo: get_usage_text can be generalised to any Rd section but it is better to use a # different approach since print.Rd() does not take care for some details (escaping # %, for example). Also, the functions that use this one assume that it returns R # code which may not be the case if the usage section contains Rd comments. # get_usage_text("../gbRd/man/Rd_title.Rd") get_usage_text <- function(rdo){ # ut <- get_usage_text("../gbRd/man/Rd_fun.Rd") if(is.character(rdo) && length(rdo)==1) rdo <- permissive_parse_Rd(rdo) # Alternatives: pos <- .locate_sec_content(rdo, "\\usage") # wrk <- Rdo_section(rdo, "\\usage") # wrk <- tools:::.Rd_get_section(rdo, "usage") # todo: maybe the following 3 lines would be more generally useful? #2012-10-04 drop comments and specials rdo_u <- toolsdotdotdot.Rd_drop_nodes_with_tags(rdo[[pos]], c("COMMENT","\\special")) wrk <- structure(rdo_u, Rd_tag = "Rd") class(wrk) <- "Rd" paste(capture.output(print(wrk)), collapse="\n") } Rdo_show <- function(rdo){ # 2012-09-22 renamed, was Rd_show outfile <- tempfile(fileext = ".txt") file.show(Rd2txt(rdo, outfile)) unlink(outfile) invisible(NULL) } Rdo_reparse <- function(rdo){ outfile <- tempfile(fileext = "Rd") Rdo2Rdf(rdo, file = outfile) rdo <- permissive_parse_Rd(outfile) unlink(outfile) rdo } Rdo_collect_aliases <- function(rdo){ pos <- Rdo_locate(rdo, function(x) .tag_eq(x,"\\alias"), lists=TRUE) res <- sapply(pos, function(x) as.character(rdo[[ x ]])) nams <- sapply(pos, function(x){ if( length(x) == 1) "" else # 2012-10-13 as.character(rdo[[ c(x[1:(length(x)-2)],1) ]]) as.character(rdo[[ c(x[seq_len(length(x)-2)],1) ]]) }) names(res) <- gsub("[ \n]" , "", nams) res } # 2013-12-02 derived from Rdo_collect_aliases() Rdo_collect_metadata <- function(rdo, sec){ #sec is "alias", "keyword" or similar simple one secname <- paste0("\\", sec) pos <- Rdo_locate(rdo, function(x) .tag_eq(x, secname), lists=TRUE) res <- sapply(pos, function(x) as.character(rdo[[ x ]])) nams <- sapply(pos, function(x){ if( length(x) == 1) "" else # 2012-10-13 as.character(rdo[[ c(x[1:(length(x)-2)],1) ]]) as.character(rdo[[ c(x[seq_len(length(x)-2)],1) ]]) }) names(res) <- gsub("[ \n]" , "", nams) res } Rdo_fetch <- function(Rd_name = character(0), package, dir = ".", installed = TRUE){ db <- if(missing(package)){ tools::Rd_db(dir = dir) }else{ if(installed) # use lib.loc to avoid highjacking by devtools tools::Rd_db(package, lib.loc = .libPaths()) else{ # d <- find.package(package) if(dir.exists(file.path(d, "man"))) # in source directory tools::Rd_db(dir = d) else # installation directory tools::Rd_db(package) } } if(length(Rd_name) == 1) db[[paste0(Rd_name, ".Rd")]] else if(length(Rd_name) == 0) db else db[paste0(Rd_name, ".Rd")] } Rdpack/R/repromptAny.R0000644000175000017500000003143313501141722014454 0ustar nileshnilesh## 2018-02-07 new ereprompt <- function(..., edit = TRUE, filename = TRUE){ reprompt(..., filename = filename, edit = edit) } ## 2018-02-07 new argument `edit' reprompt <- function(object, infile = NULL, Rdtext = NULL, final = TRUE, type = NULL, package = NULL, methods = NULL, # for the call to promptMethods verbose = TRUE, filename = NULL, sec_copy = TRUE, edit = FALSE, ...){ objmis <- missing(object) tidyflag <- from_infile <- FALSE # If 'object' is a string ending in ".Rd" and containing # at least one "/", it is taken to be "infile"; a # (somewhat dubious) convenience feature for the common # mistake of omitting the name of the "infile" argument. if(is.null(infile) && length(object) == 1 && is.character(object) && grepl("/.*[.][Rr]d$", object) ) infile <- object if(!is.null(Rdtext)){ # process Rdtext, if present if(is.null(infile)){ infile <- tempfile() cat(Rdtext, file = infile, sep = "\n") # save parsed Rdtext to 'infile' on.exit(unlink(infile)) }else cat("both 'infile' and 'Rdtext' are given, ignoring Rdtext\n") } if(!objmis && inherits(object, "Rd")){ if(verbose) cat("Processing the Rd object...\n") if(!is.null(infile)) cat("ignoring 'infile' and/or 'Rdtext' since 'object' is of class 'Rd'\n") rdo <- object }else if(!is.null(infile)){ if(verbose) cat("\nParsing the Rd documentation in file", infile, "...\n") else cat("\n", basename(infile), ": ") if(!file.exists(infile)){ # 2018-02-07 new wrk <- try(rprojroot::find_root_file("man", basename(infile), criterion = rprojroot::is_r_package), silent = TRUE) if(inherits(wrk, "try-error")) stop("Input file ", infile, " not found") else infile <- wrk } rdo <- permissive_parse_Rd(infile) from_infile <- TRUE }else{ if(verbose) cat("Rd source not supplied, looking for installed documentation.\n") fnam <- if(is.character(object)) object else deparse(substitute(object)) rdo <- .capture_installed_help(fnam, type = type, package=package) if(inherits(rdo,"try-error")) cat("Rd source not supplied and installed documentation not found.\n") else{ if(verbose) cat("Installed documentation found, processing it...\n") rdo <- .order_sections(rdo) # the sections may not be in canonical order in tidyflag <- TRUE # instaled help } } if(inherits(rdo, "Rd")){ # do the main job: inspect the documentation object res <- inspect_Rd(rdo, package = package) }else{ # documentation not found, try to generate fresh one if(verbose) cat("Trying a 'prompt' function to generate documentation for the object.\n") # 2012-11-04 arg. type, package res <- .capture_promptAny(fnam, type = type, package = package, final = final, methods = methods) if(inherits(res,"try-error")) stop("unsuccessful attempt to create Rd doc. using a 'prompt' function.") else if (verbose) cat("\tsuccess: documentation generated using a 'prompt' function.\n") } if(tidyflag) res <- .Rd_tidy(res) # tidy() could do more, if(is.null(filename)){ # generate appropriate file name; todo: may need some mangling? filename <- if(is.null(infile)) paste(res[[ Rdo_which_tag_eq(res, "\\name") ]], ".Rd", sep="") else basename(infile) # do not overwrite unless in the current dir }else if(isTRUE(filename)){ # 2018-02-07 new filename <- if(is.null(infile)) paste(res[[ Rdo_which_tag_eq(res, "\\name") ]], ".Rd", sep="") else infile # will overwrite } # todo: error checking if(is.character(filename) || identical(filename, FALSE)){ # convert to Rdtext res <- Rdo2Rdf(res, ex_restore = TRUE, file = if(is.character(filename)) filename else NULL, srcfile = if(from_infile && sec_copy) infile else NULL ) if(is.character(filename)) res <- invisible(filename) # return only the file name in this case } if(edit && is.character(filename)){ ## 2018-02-07 new argument `edit' file.edit(res) # TODO: check that it is a filename res }else res } # (promptMethods) todo: filename = FALSE is a useful # alternative. In that case the text is returned in a named list # containing one element for each Rd section (multiple occurences # of sections like '\alias' are grouped together. # 2012-11-04 new arg. type, package .capture_promptAny <- function(fnam, type, package, final, ..., methods){ # 2012-11-04 promenyam za da raboti is replacement methods, e.g. "[<--methods" # # if(grepl("^([^-]+)-.*", fnam)){ # fnam is of the form xxxx-yyy # fname <- gsub("^([^-]+)-.*", "\\1", fnam) # type <- gsub("^([^-]+)-(.*)", "\\2", fnam) # without "-" # ## suffix <- gsub("^([^-]+)(-.*)", "\\2", fnam) # with "-" # }else{ # fname <- fnam # type = "" # } # 2012-11-04 replacing with the code after the comments # # namreg <- "^(.+)-([^-]+)$" # if(grepl(namreg, fnam)){ # fnam is of the form xxxx-yyy (non-empty rhs) # fname <- gsub(namreg, "\\1", fnam) # namtype <- gsub(namreg, "\\2", fnam) # without "-" # ## suffix <- gsub("^([^-]+)(-.*)", "\\2", fnam) # with "-" # }else{ # fname <- fnam # namtype = "" # } wrknam <- .parse_long_name(fnam) fname <- wrknam["name"] namtype <- wrknam["type"] if(missing(type) || is.null(type)) type <- namtype else if(namtype != "" && !identical(type, namtype)){ cat("The name and type arguments give conflicting 'type' information.\n") cat("\tUsing argument 'type'.\n") }# else 'type' has the value needed. ## 2019-04-26 print a message since otherwise the error is not clear, ## e.g. if the call has 'type = class' (note: no quotes around class) if(!is.character(type) || length(type) != 1L) print("!!! if not missing, 'type' must be a character string") wrk <- try(switch(type, methods = { if(is.null(methods) && !is.null(package)) methods <- findMethods(fname, where = asNamespace(package)) if(is.null(methods)) promptMethods(f=fname, filename = NA) else promptMethods(f=fname, filename = NA, methods=methods) }, class = promptClass(clName=fname, filename = NA), package = promptPackageSexpr(fname, filename = NA), ## default # v tozi variant ima problemi za funktsii ot Rdpack, za koito parviyat # "if" dava TRUE i sled tova stava greshka. Za funktsii ot drugi paketi # tova ne e problem, ponezhe za tyach "if"-at dava FALSE, ako sa # nevidimi. # # Tay kato tazi situatsiya mozhe da vaznikne po razlichni nachini, # promenyam koda. Tryabva oste rabota za sluchaya kogato ima poveche ot # edno ime... ### if(exists(fname, envir = parent.frame())){ ### prompt(object=fname, filename = NA, force.function=TRUE, ...) ### }else{ # todo: needs more work here ### x0 <- do.call(getAnywhere,list(fname)) ### browser() ### prompt(object=x0$objs[[1]], filename = NA, force.function=TRUE, ### name = fname, ...) ### } { wrk0 <- try(prompt(name=fname, filename = NA, ...), silent=TRUE) if(inherits(wrk0,"try-error")){ x0 <- do.call(getAnywhere,list(fname)) wrk0 <- prompt(object=x0$objs[[1]], filename=NA, name = fname, # force.function=TRUE, ...) } wrk0 # todo: needs more work here. IN particular, there should be a # package argument to avoid taking blindly whatever comes up. } ) , silent = TRUE) if(inherits(wrk,"try-error")) res <- wrk else{ res <- .parse_Rdlines(wrk) # if successful, res is not inspected here # since it is generated from the actual definitions. if(final && type != "package"){ # put dummy title and description # to avoid errors when installing a package wrk <- char2Rdpiece("~~ Dummy title ~~", "title") res <- Rdo_replace_section(res, wrk) wrk <- char2Rdpiece("~~ Dummy description ~~", "description") res <- Rdo_replace_section(res, wrk) # tidy a bit, e.g. to start each section on new line, # which may not be the case for installed documentation res <- .Rd_tidy(res) # tidy() could do more; e.g. reorder sections } } res } .capture_installed_help <- function(fnam, type = NULL, package = NULL, suffix = NULL){ # this does not work, package seems not evaluated or deparsed # hlp <- help(paste(fnam, "-methods", sep=""), package=package) # TODO: the last example in "help()" amy be helpful here. # namreg <- "^(.+)-([^-]+)$" # 2012-11-04 new namreg and related fullname <- if(grepl(namreg, fnam)) # fnam is of the form xxxx-yyy fnam else if(!is.null(type) && is.character(type) && type!="") paste(fnam, "-", type, sep="") else if(!is.null(suffix)) paste(fnam, suffix, sep="") else fnam hlp <- help(fullname) # todo: more care! hlpfile <- as.vector(hlp) # removes attributes # todo: but may be of length > 1, e.g. for "initialize" # cat("hlpfile has ", length(hlpfile), " element(s):\n") # print(hlpfile) if(!is.null(package)){ # try first "/package/" to avoid surprise matches; # see what happens with package = "methods", without the slashes; # also, 'package' may be part of the name of another package. indx <- which( grepl(paste("/", package, "/", sep=""), hlpfile)) if(length(indx)==0) # ... but if nothing matched, try without the slashes. indx <- which(grepl(package, hlpfile)) hlpfile <- hlpfile[ indx ] } if(length(hlpfile) > 1){ # todo: mozhe da se napravi v loop to collect a bunch of sig's hlpfile <- hlpfile[1] cat("length(hlpfile)>1, taking the first element.\n") } try(utilsdotdotdot.getHelpFile(hlpfile), silent=TRUE) } # 'usage' may be an "f_usage" object obtained e.g. by a # previous call to get_usage() or generated programmatically. promptUsage <- function (..., usage){ # todo: add formatting options? if(missing(usage)) get_usage(..., out.format="text") else as.character(usage) } Rdpack/inst/0000755000175000017500000000000014203665045012572 5ustar nileshnileshRdpack/inst/CITATION0000644000175000017500000000074413677126365013747 0ustar nileshnileshcitHeader("To cite the 'Rdpack' package in publications use:") year <- sub("-.*", "", meta$Date) vers = paste('R package version', meta$Version) bibentry(bibtype = "Misc", title = "{Rdpack}: Update and Manipulate Rd Documentation Objects", author = person(given = c("Georgi", "N."), family = "Boshnakov"), year = year, note = vers, doi = "10.5281/zenodo.3925612" #, url = "https://CRAN.R-project.org/package=Rdpack" ) Rdpack/inst/auto/0000755000175000017500000000000014177730325013546 5ustar nileshnileshRdpack/inst/auto/REFERENCES.el0000644000175000017500000000025714177730325015515 0ustar nileshnilesh(TeX-add-style-hook "REFERENCES" (lambda () (LaTeX-add-bibitems "Rpack:bibtex" "Rpackage:rbibutils" "parseRd" "Rdevtools" "dummyArticle")) :bibtex) Rdpack/inst/doc/0000755000175000017500000000000014203665045013337 5ustar nileshnileshRdpack/inst/doc/Inserting_bibtex_references.Rnw0000644000175000017500000004201014177561276021537 0ustar nileshnilesh% Created 2022-02-05 Sat 20:49 % Intended LaTeX compiler: pdflatex \documentclass[a4paper,twoside,11pt,nojss,article]{jss} \usepackage[T1]{fontenc} \usepackage[left=2cm,right=2cm,bottom=15mm]{geometry} \usepackage{graphicx,color,alltt} \usepackage[authoryear,round,longnamesfirst]{natbib} \usepackage{hyperref} % \usepackage{Sweave} \author{Georgi N. Boshnakov} \Plainauthor{Georgi N. Boshnakov} \Address{ Georgi N. Boshnakov\\ School of Mathematics\\ The University of Manchester\\ Oxford Road, Manchester M13 9PL, UK\\ URL: \url{http://www.maths.manchester.ac.uk/~gb/} } <>= library(Rdpack) pd <- packageDescription("Rdpack") @ \Abstract{ Package \pkg{Rdpack} provides a straightforward way to insert BibTeX references in the documentation of an R package, using the RdMacros feature introduced in R~3.2.0. It works for `roxygen2' documentation, as well. \par This vignette is part of package Rdpack, version~\Sexpr{pd$Version}. } \Keywords{bibliographic references, Rd, bibtex, citations, \proglang{R}} \Plainkeywords{bibliographic references, Rd, bibtex, citations, R} \author{Georgi N. Boshnakov} \date{\today} \title{Inserting references in Rd and roxygen2 documentation} \hypersetup{ pdfauthor={Georgi N. Boshnakov}, pdftitle={Inserting references in Rd and roxygen2 documentation}, pdfkeywords={bibliographic references, Rd, bibtex, citations, R}, pdfsubject={}, pdfcreator={Emacs 26.3 (Org mode 9.1.9)}, pdflang={English}} \begin{document} \maketitle %\SweaveOpts{engine=R,eps=FALSE} %\VignetteIndexEntry{Inserting references in Rd and roxygen2 documentation} %\VignetteDepends{Rdpack} %\VignetteKeywords{bibliographic references, Rd, bibtex, citations, R} %\VignettePackage{Rdpack} \section{Setup} \label{sec:org985340a} To prepare a package for importing BibTeX references it is necessary to tell the package management tools that package \pkg{Rdpack} and its Rd macros are needed. The references should be put in file \texttt{inst/REFERENCES.bib}. These steps are enumerated below in somewhat more detail for convenince: \begin{enumerate} \item Add the following lines to file `DESCRIPTION': \begin{verbatim} Imports: Rdpack RdMacros: Rdpack \end{verbatim} Make sure the capitalisation of \texttt{RdMacros} is as shown. If the field 'RdMacros' is already present, add `Rdpack' to the list on that line. Similarly for field 'Imports'. \item Add the following line to file `NAMESPACE'\footnote{Any function for package \pkg{Rdpack} will do. This is to avoid getting a warning from 'R CMD check'.}: \begin{verbatim} importFrom(Rdpack,reprompt) \end{verbatim} The equivalent line for `roxygen2' is \begin{verbatim} #' @importFrom Rdpack reprompt \end{verbatim} \item Create file \texttt{REFERENCES.bib} in subdirectory \texttt{inst/} of your package and put the bibtex references in it. \end{enumerate} \section{Inserting references in package documentation} \label{sec:org30fe476} Once the steps outlined in the previous section are done, references can be inserted in the documentation as \texttt{\textbackslash{}insertRef\{key\}\{package\}}, where \texttt{key} is the bibtex key of the reference and \texttt{package} is your package. This works in Rd files and in roxygen documentation chunks. In fact, argument 'package' can be any installed R package\footnote{There is of course the risk that the referenced entry may be removed from the other package. So this is probably only useful for one's own packages. Also, the other package would better be one of the packages mentioned in DESCRIPTION.\}}, not necessarily the current one. This means that you don't need to copy references from other packages to your \texttt{"REFERENCES.bib"} file. This works for packages that have \texttt{"REFERENCES.bib"} in their installation directory and for the default packages. See also the help pages \texttt{?Rdpack::insertRef} and \texttt{?Rdpack::Rdpack-package}. For example, the help page \texttt{?Rdpack::insertRef} contains the following lines in section ``References'' of the Rd file: \begin{verbatim} \insertRef{Rpack:bibtex}{Rdpack} \end{verbatim} The first line above inserts the reference labeled \texttt{Rpack:bibtex} in Rdpack's \texttt{REFERENCES.bib}. The second line inserts the reference labeled \texttt{R} in file \texttt{REFERENCES.bib} in package `bibtex'. A roxygen2 documentation chunk might look like this: \begin{verbatim} #' @references #' \insertRef{Rpack:bibtex}{Rdpack} \end{verbatim} \section{Inserting citations} \label{sec:org9601ff6} From version 0.7 of \pkg{Rdpack}, additional Rd macros are available for citations\footnote{They were introduced in the development version 0.6-1, but 0.7 is the first version with them released on CRAN.}. They can be used in both Rd and roxygen2 documentation. If you are using these, it will be prudent to require at least this version of Rdpack in the ``Imports:'' directive in file DESCRIPTION: \texttt{Rdpack (>= 0.7)}. \subsection{Macros for citations} \label{sec:org9454f29} \label{sec:macros-citations} \texttt{\textbackslash{}insertCite\{key\}\{package\}} cites the key and records it for use by \texttt{\textbackslash{}insertAllCited\{\}}, see below. The style of the citations is author-year. The ''et al'' convention is used when there are more than two authors\footnote{This feature was introduced in Rdpack 0.8-2.}. \code{key} can contain more keys separated by commas. Here are some examples (on the left is the code in the documentation chunk, on the right the rendered citation): \begin{center} \begin{tabular}{ll} Documentation source & rendered\\ \hline \texttt{\textbackslash{}insertCite\{parseRd\}\{Rdpack\}} & (Murdoch 2010)\\ \texttt{\textbackslash{}insertCite\{Rpack:bibtex\}\{Rdpack\}} & (Francois 2014)\\ \texttt{\textbackslash{}insertCite\{parseRd,Rpack:bibtex\}\{Rdpack\}} & (Murdoch 2010; Francois 2014)\\ \end{tabular} \end{center} By default the citations are parenthesised \texttt{\textbackslash{}insertCite\{parseRd\}\{Rdpack\}} produces \Sexpr{ insert_citeOnly("parseRd", "Rdpack") }, as in the examples above. To get textual citations, like \Sexpr{ insert_citeOnly("parseRd;textual", "Rdpack") }, put the string \texttt{;textual} at the end of the key. Here are the examples from the table above, rendered as textual citations: \begin{center} \begin{tabular}{ll} Documentation source & rendered\\ \hline \texttt{\textbackslash{}insertCite\{parseRd;textual\}\{Rdpack\}} & Murdoch (2010)\\ \texttt{\textbackslash{}insertCite\{Rpack:bibtex;textual\}\{Rdpack\}} & Francois (2014)\\ \texttt{\textbackslash{}insertCite\{parseRd,Rpack:bibtex;textual\}\{Rdpack\}} & Murdoch (2010); Francois (2014)\\ \end{tabular} \end{center} The last line in the table demonstrates that this also works with several citations. To mix the citations with other text, such as ``see also'' and ``chapter 3'', write the list of keys as a free text, starting it with the symbol \texttt{@} and prefixing each key with it. The \texttt{@} symbol will not appear in the output. For example, the following code: \begin{verbatim} \insertCite{@see also @parseRd and @Rpack:bibtex}{Rdpack} \insertCite{@see also @parseRd; @Rpack:bibtex}{Rdpack} \insertCite{@see also @parseRd and @Rpack:bibtex;textual}{Rdpack} \end{verbatim} produces: \qquad \begin{tabular}{l} Rendered\\ \hline \Sexpr{insert_citeOnly("@see also @parseRd and @Rpack:bibtex", "Rdpack")}\\ \Sexpr{insert_citeOnly("@see also @parseRd; @Rpack:bibtex", "Rdpack")}\\ \Sexpr{insert_citeOnly("@see also @parseRd and @Rpack:bibtex;textual", "Rdpack")}\\ \end{tabular} The text of the arguments of the macro in this free form should have no markup. For example, if you want to put the phrase \texttt{see also} in italic, enclosing it with \texttt{\textbackslash{}emph\{...\}} (in Rd) or the equivalent \texttt{\_...\_} (in markdown) will not work\footnote{For details see \href{https://github.com/GeoBosh/Rdpack/issues/23}{Github issue \#23} raised by Martin R. Smith.}. For textual citations a workaround is to invoke \texttt{\textbackslash{}insertCite} for each key and type the markup outside the macro arguments. For parenthetical citations the solutions is to ask \texttt{\textbackslash{}insertCite} to omit the parentheses by putting \texttt{;nobrackets} at the end of the argument\footnote{With \pkg{Rdpack} versions greater than 2.1.3.}. The parentheses can then be put manually where needed. For example, \begin{verbatim} (\emph{see also} \insertCite{@@parseRd and @Rpack:bibtex;nobrackets}{Rdpack}) \end{verbatim} produces: (\emph{see also} \Sexpr{insert_citeOnly("@@parseRd and @Rpack:bibtex;nobrackets", "Rdpack")}). \subsubsection{Further macros for citations} \label{sec:orgb8b5f68} The macro \texttt{\textbackslash{}insertNoCite\{key\}\{package\}} records one or more references for \texttt{\textbackslash{}insertAllCited} but does not cite it. Setting \texttt{key} to \texttt{*} will record all references from the specified package. For example, \texttt{\textbackslash{}insertNoCite\{R\}\{bibtex\}} records the reference whose key is \texttt{R}, while \texttt{\textbackslash{}insertNoCite\{*\}\{utils\}} records all references from package ``utils'' for inclusion by \texttt{\textbackslash{}insertAllCited}. \texttt{\textbackslash{}insertCiteOnly\{key\}\{package\}} is as \texttt{\textbackslash{}insertCite} but does not record the key for the list of references assembled by \texttt{\textbackslash{}insertAllCited}. \subsection{Automatically generating lists of references} \label{sec:org9550879} The macro \texttt{\textbackslash{}insertAllCited\{\}} can be used to insert all references cited with \texttt{\textbackslash{}insertCite} or \texttt{\textbackslash{}insertNoCite}. A natural place to put this macro is the references section. The Rd section may look something like: \begin{verbatim} \references{ \insertAllCited{} } \end{verbatim} The analogous documentation chunk in roxygen2 might look like this: \begin{verbatim} #' @references #' \insertAllCited{} \end{verbatim} \subsection{Changing the style of references} \label{sec:org9be8049} Package \texttt{Rdpack} supports bibliography styles for lists of references\footnote{Support for styles is available since \texttt{Rdpack (>= 0.8)}.}. Currently the only alternative offered is to use long names (Georgi N. Boshnakov) in place of the default style (Boshnakov GN). More comprehensive alternatives can be included if needed or requested. To cause all lists of references produced by \texttt{\textbackslash{}insertAllCited} in a package to appear with full names, add \texttt{.onLoad()} function to your package. If you don't have \texttt{.onLoad()}, just copy the following definition: <<>>= .onLoad <- function(lib, pkg){ Rdpack::Rdpack_bibstyles(package = pkg, authors = "LongNames") invisible(NULL) } @ %def If you already have \texttt{.onLoad()}, add the line containing the \texttt{Rdpack::Rdpack\_bibstyles} call to it. After installling/reloading your package the lists of references should appear with long author names. "Rdpack" itself now uses this style. \section{Possible issues} \label{sec:orgbf633c1} \subsection{Warning from 'R CMD build'} \label{sec:org73ebe35} If 'R CMD build' or \texttt{devtools::build()} gives a warning along the lines of: \begin{verbatim} Warning: C:/temp/RtmpqWQqji/.../XXX.Rd:52: unknown macro '\insertRef' \end{verbatim} then check the syntax in file DESCRIPTION --- the most common cause of this is misspelling \texttt{RdMacros:}. Make sure in particular that `M' is uppercase. \subsection{Development using `devtools'} \label{sec:orgf96b5aa} The described procedure works transparently in `roxygen2' chunks and with Hadley Wickham's `devtools'. Packages are built and installed properly with the `devtools' commands and the references are processed as expected. Currently (2017-08-04) if you run help commands \texttt{?xxx} for functions from the package you are working on and their help pages contain references, you may encounter some puzzling warning messages in `developer' mode, something like: \begin{verbatim} 1: In tools::parse_Rd(path) : ~/mypackage/man/abcde.Rd: 67: unknown macro '\insertRef' \end{verbatim} These warnings are again about unknown macros but the reason is completely different: they pop up because ``devtools'' reroutes the help command to process the developer's Rd sources (rather than the documentation in the installed directory) but doesn't tell \texttt{parse\_Rd} where to look for additional macros\footnote{The claims in this sentence can be deduced entirely from the informative message. Indeed, (1)\textasciitilde{}the error is in processing a source Rd file in the development directory of the package, and (2)\textasciitilde{}the call to \texttt{\textbackslash{}parse\_Rd} specifies only the file.}. These warnings are harmless - the help pages are built properly and no warnings appear outside ``developer'' mode, e.g. in a separate R\textasciitilde{}session. You may also consider using the function \texttt{viewRd()}, discussed below, for viewing Rd files. \subsection{Latex markup in BibTeX entries} \label{sec:org7310075} In principle, BibTeX entries may contain arbitrary Latex markup, while the Rd format supports only a subset. As a consequence, some BibTeX entries may need some editing when included in REFERENCES.bib\footnote{Thanks to Michael Dewey for suggesting the discussion of this.}. Only do this for entries that do not render properly or cause errors, since most of the time this should not be necessary. For encoding related issues of REFERENCES.bib see the dedicated subsection below. If mathematics doesn't render properly replace the Latex dollar syntax with Rd's \texttt{\textbackslash{}eqn}, e.g. \texttt{\$x\textasciicircum{}2\$} with \texttt{\textbackslash{}eqn\{x\textasciicircum{}2\}}. This should not be needed for versions of Rdpack 0.8-4 or later. Some Latex macros may have to be removed or replaced with suitable Rd markup. Again, do this only if they cause problems, since some are supported, e.g. \texttt{\textbackslash{}doi}. See also the overview help page, \code{help("Rdpack-package")}, of \pkg{Rdpack}. Among other things, it contains some dummy references which illustrate the above. \subsection{Encoding of file REFERENCES.bib} \label{sec:org9cfdd04} If a package has a declared encoding (in file \texttt{DESCRIPTION}), \texttt{REFERENCES.bib} is read-in with that encoding\footnote{From \texttt{Rdpack (>=0.9-1)} The issue of not handling the encoding was raised by Professor Brian Ripley.}. Otherwise, the encoding of \texttt{REFERENCES.bib} is assumed to be UTF-8 (which includes ASCII as a subset). Note that BibTeX entries downloaded from online databases and similar sources may contain unexpected characters in other encodings, e.g. 'latin1'. In such cases the check tools in R-devel (since about 2018-10-01) may give warnings like: \begin{verbatim} prepare_Rd: input string 1 is invalid in this locale \end{verbatim} To resolve this, convert the file to the declared encoding or UTF-8. Alternatively, replace the offending symbols with their classic \TeX{}/\LaTeX{} equivalents (which are ASCII). Non-ASCII symbols in BibTeX entries obtained from online databases are often in fields like "Abstract", which are normally not included in lists of references and can be deleted from REFERENCES.bib. One way to check for non-ASCII symbols in a file is \texttt{tools::showNonASCIIfile()}. Since \pkg{Rdpack} switched to the bibtex parser in package \pkg{rbibutils}, if the bib file contains Latex escape sequences standing for accented Latin characters, such as \texttt{\textbackslash{}'e} and \texttt{\textbackslash{}"o}, they are imported as is. They are converted to UTF-8 only when the text is rendered for output. If R's checking tools complain about non-ASCII characters add the following encoding declaration to file DESCRIPTION\footnote{Admittedly, this is not ideal since the user should not need to care how things are processed internally but I haven't pinpointed the exact cause for this.}: \begin{verbatim} Encoding: UTF-8 \end{verbatim} Needless to say, make sure that there are really no characters from encodings like 'latin1'. With the previous bibtex parser (before Rdpack version 1.1.0) the conversion was done earlier, which resulted in confusing messages about non-ASCII characters, even when the file REFERENCES.bib was pure ASCII. This should no longer happen. \section{Viewing Rd files} \label{sec:org4a228d2} A function, \code{viewRd}, to view Rd files in the source directory of a package was introduced in version 0.4-23 of \pkg{Rdpack}. A typical user call would look something like: \begin{verbatim} Rdpack::viewRd("./man/filename.Rd") \end{verbatim} By default the requested help page is shown in text format. To open the page in a browser, set argument \code{type} to \code{"html"}: \begin{verbatim} Rdpack::viewRd("./man/filename.Rd", type = "html") \end{verbatim} Users of 'devtools' can use \code{viewRd()} in place of \code{help()} to view Rd sources\footnote{Yes, your real sources are the \texttt{*.R} files but \code{devtools::document()} transfers the roxygen2 documentation chunks to Rd files (and a few others), which are then rendered by \pkg{R} tools.}. \end{document} Rdpack/inst/doc/Inserting_bibtex_references.pdf0000644000175000017500000062645014203665043021545 0ustar nileshnilesh%PDF-1.5 % 59 0 obj << /Length 2855 /Filter /FlateDecode >> stream xڵY[o8~ϯv5+R.}^Lhvf=7R.X/|,N䇳Lfg9Rl2J*JJSʓ"^lu-glϧyS\ӿlx-%44i.kMkW,)!nM=Wُ|j ARYW'SkTa HŽWLh+>«mH )~YYWΓȔ-d9k,`$Sy]%w4sJ:xcת.LG6e\".4%K,c7=wUDhZAVX^_]6eϸ~m^(!QƼ{`Sw:M2_xenp}CD!f':{{jDOX1Y Ϋ<]-vh'YrCvLɴT 3)`/7ob<t/YZ(B`:!@ Htz^$"|AeYR8 KmK4\eӋ=lHJ_E1Q7eLyB,ˆZST= XB,0&Eڪ!ٍPu^%KpUI摾2$=xF `7d!^xFFd؜: nx.q$̼V;.:oR[yS|aMXyM(a g~I+$4QUYgNoS,/ ;[ҕdz*aTY&o 2ZI[P;oGN95@Fg94r+z<-WWr8ǚe:W~oA3F#.D%4;^i?=Y$y0t m$Ӏrfmi^d~CZSzo2SziOVL=:6BeSr?7kC[?p [<Ìc#h2yk ग़n`1y0x~δ{vTfATP!' >['OAkik10ԜSg*todV̄nEIo;G`\x0Bukr9wxv4iw=pV8#40gA}mDb%SbhpҧB.w؏^{IM8,oy ELۛHH//>`Lt%8uɵ>Y)zsVg;/P}Sr4-ğ;zp iڃ쑧!Mp`N18 8É8)wߐoگXy"CnX+ '6ҋ+( ^p$vxǢfqϣógs3i^Nq4HqL aRIy_5`Y;^ Zʰt% ^32rlkkjſDECQKD%7/ BDVㄫ9XY(448,tC ]=("ϙ*y[! $ScI i~F: z=Qj_w!E+ܴpA$o\8e! F{_;dl$^2`ʊS㷱'.{!:(tYn |q8sK!3J*23 dzysZs %AxJ(}t;=.Vr h{{ݰzZF{R]вPyp>+rKN=+y#|ͧi_rדmr hc[y`:wr˨Poq2s,kO@5*tC9rj/m?)y\Ȏ}S Nw1pXGMy 0'*%U\gHhk1fxB hď=pW 2۝V';aĨfx.K}&CSyRAAsW6`sx=&z M53e#P-NSQ1'{ iZG/1^]yb4YyMM -0+>5(dexcΊxUqbmL;`aA--:C/ <c_rszQ8|c KRNv 5Ede:_}4=5کԽ-O.@CUWUvyUaib'ش,TQ+ 4ҚmEaY0Uw7МrGkҫ/k+Pa'A$1.vFxirp?g7| 3UoNV׾"RZA 7Ka2j-70O^crė3`āM5ĐUD=I&*5k N2j!#גlؼhjoRq {!Bl8#TLg^G$2UθFnϣr}(! vH?c.v?#; pL߉$>X'-5YClR@d9I*(1deiAOA7xnjyUxW^dd"^Mxd k@V[b k@3}/,M UђC׈8 endstream endobj 84 0 obj << /Length 3132 /Filter /FlateDecode >> stream xZoFB~ X9y$ݴiftw]k ,#ѱaru1eڑs0h;~ۑ}whUڌNNGPEFeTYԣ觱=_O^&hW:T0 yuyh6.|pZklҕUs)7+h[rnnX}g4nԆ]q&ҰDwg * ə m8I78p)v8 Ÿ!"RqLl;vhq lQG0oz)^p)HϧrمHME񭉙s7' Ki?3H~J#ʯfsos$TYMO8L…zH~}DVPvOaF-p_T1Zq"1:(ʸLsIk c26<'SG,4\>V ݽk81=bIz`e$38 8v~2T_rutkxgdR׸x=FCτuK]S)Zcv% R>A*6a֟$=/Hze# {Ќ!1h1dDǀh&8f ѾF,xe󸇖7*дi>+3Aa<(W?6(#3%]`g<Ӭˋ1 -m?A@ߘaUQ.y $R >̰o0yPL%tNB &&IG"aיbLQPoB~XX`*nJ"ߝ$*$*Ns8* 7$uQ-Hmf13pɸ1'ys310pd95 )L.[R% 3Θ81fdF%0SԲA0DA`|CcøjT]L )UNЁʊg|}ưF FvÞ_,(ZgZ>f^`ȍҨʊ?uC>?"l+z|\8U_hJ! L, ZSlUeO^*U X`tt[>hWR3>Ltu0ކ.}iy/?;T:ɛxjaE>)%xG|di囄h]RoKHm}ɥ{Y󪥤I'7űw =L%@LӶɴo&yL?0|>qudfYym0R`>+ endstream endobj 97 0 obj << /Length 3214 /Filter /FlateDecode >> stream xڽYo}/rzLf/:~NP" `ʚ\2k~=1j63 &8SMr U /H~wV P4mDjs{RI ],8]LԓWn]?v-Zn75 ÃL0xr#p4<_+]VwX _4d Y7B[Sg=S 4hf /,{Gpq&;lRS0C/>nd aRmګ2 W`€ ;2&b#)ҬLy4I~VN9C> ZU΅= ("W%_F`/66.2p>gE@-qϟ8ô(YDJ`C[+k!<X-ZqXM  'w8zEg}Cވo*uo<9wfU]RK5qЬ,J, +0_1.질4&^P{iBGuԗʹvLEXKWV v(mmt' =?D ="rOfJ2P6X[h'tsÜހؼ"jf‹Ss+++*669. ͐6/bqF uha,z+Md76ތYݳٛ߭Ԏh%sd,kUTe Rj>@G1k1iL„dR>#$9;jVe5T@@e|f͆"e˨8g|$e"5o޻Ҷ7-:lo3qO 9> *Rj$T9r`0I& 51u%4>S0AP3(\vEkr.Kd5.䠴S"צɍDfNFҋbtk}Hӓ"z &x`&P]W"ǣLH"{caz1?y57LG+F9f5r$U|d-6\^^L킣%0j!L XNFJaet%bʢ|Cہi '7þfO8i`CTFяNzD$,ݺR@'8@ gBݯ nXh g$==.mZ<:#dJL欣ql4lнz!& ) q< ؁d͓aI&mZ #0;' Zvdz${N $3X]}"K~AЗhVovwn ۳=eHn%wZcxqZ$ĦCRۃ @K CB~F3O >uQQ-¸ߥQCw2`v$ eFCj `8?Pwh+L_dFфߛgS.%5?.@H[98EZ Rw&J2(%*fֺ0}!`걫o6S\}'S%%_5թ!3'7/^+Uc߄[NpRD]:a[j/W!U\4 N3{O`j2F Z^i4*ː&[ʡa{]8$2ox9$seHŤ1 ob1[İjK=9]U!]w5w3d˱P'C/RSp~Q'D|)B 5aZ@eАp:7 t9lxPgl(?\.RU1@y7(I2bD"Y endstream endobj 111 0 obj << /Length 3341 /Filter /FlateDecode >> stream xڽZ[s~ׯE4\-L/q뎝N܉3\JH.KZV\rԙ~jO|rb⨊+3\N<ʫdRYTr1axg 'FqV|{f}=[{fIL;X(_㘕4b]Vg~kyf06?@sCc8u~yϟ8 O1c̒,*dzYfiDKA^Hς7Zr+wrc I[\ s Hd`Bm9}Y5#6&T11^>9U2mlY\> c]8NxuY+KIğ at2bw2[eJDG;Di)8p ;!ʈ376PriWP1Rܢm-vq-3 |-vҫ%g.:dKIO7FvSkd+(_~*8Zu#*Zl)ƹ.YnߒwA7@U!Ek2φx ܃],7@QE[bPLdPᚍW OΥVk0~⿋?-TG~&ic lz#{Qq1 W -g?8I.fnjY#:yIsag@=( uAOsYHLxsmH7ydS>a3%T؎q FAa*cQ]p7Znr0>FPpJoRh|jEfՎpǯ1>=d /vMe՘h}ᎢN/t:(HݱkIe7t-YFX* a}4VWedRL~7nv[nEnxKSA+s#p ~GIA xRDUsœDiL"rt0-eXF e0GwyD7GjlhiF5h$_<&TN"xQ)_p-)4 Z[`lРF8*c4VGX<_{Nth ^ ID16Tf9p5moGa19=;0ceUX26%fCDуqx\D(+:1KxX]]#>|QM* 1cGѡtˬLsu5o= Tf${f3lƳ(5/La4 )ٮ ]"O G2{8˹3,?R'TTo$2qF?L`NvUDJ`O+mhE/4[B5;Ibm. vlf"S.@epUET&#Gme9e` %5!Ey[:iY8ɽ\F {1 :gBg ˺ZA,Mozѳq'M3BKKT A`D´A#h헗'N џb2ߜcDIZU9i1' ˮ w3K{ǫkޕ ;>mІgd !&?`nG(+蝲 }PbJ,ŒĊts-h‹Xm{Pͧ)l<+^-I3 ^ZTU2 qs%:Z \Je endstream endobj 126 0 obj << /Length 3755 /Filter /FlateDecode >> stream xZ[o~,,g8Hv7ppRH҂([XItDɎQf8CѻiЇ E r9nL=yss}':QURrbl3Uf1i홞6߭fijW hk{?rڞbx_^/+ui $̖ZdfssEr. 9\Wnl 7Us[x#6xY^qP  h2M-ktϸe|׸S:˄I;zS+kJ3P2&f([!M5!_ipYafTI9TeVEYXUc {dL+kVAM7ȑUI2 n=-ih eGIEj"gb!׋Oܔ ˙2  GL̊\`LJ'OW*/](2 $75.5+n xH6m0I]*;`0 Hx[{Yz6}qtYnƙ(:sj|r|&˘8Ă3 FTtni\e%7ow5L۳9^R/SZUj |h4a_R`4)TQcyip׵*x xąqOM[9;JeݽhZXs% k9&&\6^4z2ڀ7ʪYHCAP±&fBu=\NUq=ؐ b:u"Y1]4Lؘ¶t[NR!JoA։xLKےW+ J؃.j-y@bTO],3H,PT+](V ;R( OvhTy࿫QTa>BA`~BLs; `ً;Fq&! =xķ.p}׍9u+(xcj)P pIOh-ŅqcD/3I\5p5|g3 8ёoE"lCȷ~MI"adTRU$C'HUA X;wҶ'FpJ]Y5" "^2*CVU:dȝmĭcܣ J{%7m޾IVdelX]_.2ԂjA*]#,9Wu(B|f%Ժ9+[ȭG廕̎ţGйZ,k/ԫo.ظȋk =0Є6($.Xm m;Bh-*qO]=~p=lWOq!$N^!^:$T ) 9Oܺ:H;,*5#km"#YCÞIt9 *II@p n𞨾6BIב Lp^Uckr ׀rr+hy Yz##Nɀj`GzqD{/yXt/ܻtݛCndӋ[2N;s=1?\/R@7[7OQ3'#fg!h v$d[:ulx}j^oc%{\cN2zw7˥1ox.:A>Bw$c6(G7 W/eFM!VՑ{[R΃t+&".Z:|&)+FÄMe5# ^ sfE8߇bݓKȱܻ]Z_W."x!KN3f>1˝(FT_Iѣب<`x.q 4k.7on!Vc =WU!e:{ miq5)2b<}`S?X,جpHF4Fl6NLq՝~. ^Jsʗ\eKUaȊ{'#- "6q|D o%>(n9maNN%MS^@E3#̮(퐇bP.HX-)s& ?UAڎSK.ۥOSjUMa_0QEwQUY<\B"b~L{I/OW\s^zt6RA4ufz?] fρQ S^JTK1hswc(v|,oJH^C]#4,Yc&FD&T 3$Szl+[h]ӛ(£*Ĉeawf}˿\5Yn93$orMZH`V?Iڈu ^\#!QzB > t(Ԋ| Wtp)i50xt4Ǐ1*e*L<[> ,xK2ӛTK 7(]tGVG'!g g*$teH+ -cu[Y_Ӯu,K@V:g\j:evEߎR.I]%4q̱dRs $}`?v7U=#eV  x+ z#2`&*RO2ؤqZ @ǥ2*#_S0JFU0gJ#7`1Բ>"h>AT;<*pB 4P g[6R\^;+cNAk/x7n @sKڈ[]+8a /JUYx re{;"Nk+a^`M4HBOUjiӫ?_O4A|=rV@_@T MO4p3ѕQEf=xWt2 2(rgʂ2kϯ߃a[փ2zҷki4^'&xX# ,L + td$=ˍO ccɷ[ C<>`1p##.=&C׹ ~B,)S}|O:ER.xkJhA9 1sA5L |蟅qy!P[)a1,e[D @F }%ObC>. bt4rts;YJyE }Ern-83kY.8XGG2u*`gpYG'AQUi:6H@OhвbU70Fጨ endstream endobj 134 0 obj << /Length 948 /Filter /FlateDecode >> stream xڅVKs6Wx[2SgڦIȇNMQ_ۻXҔiG . )J].r*j 祏VdQ7/ zu& R/᱇ovvޢ`KR|%<eUImI7-Ț yYt7$Z|d>g}Obi̽O\40٦h^yszUp. B.7gș(sz9Ttz(җf+c#YoŘJAAA8#c~_6hu@C*zv#ZBSA#h.iX%xP'*itVFLʙ Y_[gGi S2(W{Ρ8&\N9Az0Sd-ݺ[<M+]ơ~BtPz;~}: $/)TTp]#z'*CXOUHA\uGG;#?|ף ޴MxmebɃ-ql>cy!/a]:D1nֽipy:ᕬW{}٨7{t?=PFQf*#mʼnBG#tŧٟiC:hwi|UW0P/\Yl\1-rSӔV21_!xq 8G2#hÄA\M ax&4qƣb7q~k]z|is/ym}ɦ|sg U۽ć~ Bi7rehtT5jG7|Kd4i"؆[9m&G{< sk.7rQi;BHϙU'Nyp 'V5W#`7xiu5E'mdx#! endstream endobj 2 0 obj << /Type /ObjStm /N 100 /First 799 /Length 1976 /Filter /FlateDecode >> stream xڭYmo8_1~8|!X ME.GI&V`{F;#F@bRÙqH1idr2 Ě89tX82#YKdI#cL@Ak2B2d5Ed)D1R0/e`(st"C941 ཇh&[x>Q>K^-벡zmt`ݛU];|W\L֚-yumdjfRuaa:̯:X4M9 Ԡ{sT-l\~C;쟓żrQJj,GIs\ZܡIjLQa]GyS݉ ղߋ򏺪nL6ƨ_'uuŗC..fvhfP mԡzZ~>.?~?~u>;_[؂mn;Y4Xs| %?.iL>)OHI⨚XI[b\.B2vfcy1ѩB${e_$*,j8W w*[pƎ/hyk<:oEhCqt̓5䤂le UtCz_. XHNת,tP)9̦F_ƾ W77g:`_EUBu^P0 >PԵ*rJ́X28Pl!X cF!B>ꚰT!v}uGIy=Rx=%x k ƛ*>-)b1o@|{yQH(Ca()ԭQBO@f8ТREr2V x=bGI ٽ Wovq`a(f}¾yW`m"#'h3h6p3@9>_@?+ͭ _Ss lm\@Ά{NU3R?m 8H24G0]BHS6/`u{;y3Nq&W b%X4+)aS.'u]-VWzumsYBΣE{V(}r; mAj+rw5,VV O wd'gwekDzܧ֐;+/I8[Kҥ\Dr'6`LY10R{d#IUi.$Wj!@QEБrooc۠84<֣pu-g2p.SPr/IrTؙ za ?d^L+\SrT1gk\H¾2B\Ae!ȝ?+÷}r`vnlkPa߲>c'sgap?/ 'ӅXAi-_B 5ؼFUmPnqQ+Wٻ?WvKΧ.j2U/΋[unt endstream endobj 153 0 obj << /Length1 2138 /Length2 15385 /Length3 0 /Length 16662 /Filter /FlateDecode >> stream xڍPض Cpָkpwo-wwܝ@ ;<\lMe)=c h9=@;zXؚL-yqzgwgZ_NvֆFWnR~4-읝,j0,fk"bgcuv>Q GDZ{0sVvn^S [ӿ0qgPppJCGft122r39_U<+teog0hca d 8;}00v,laDMwph3~~/;[k?/?W',lcg11?s||a -Sƿ|lM\TqLS?A߱>3:l?.&(oC w[MGmhcauqXY5Vꤜ ?@h$n4Qp66gVc@;'#},1{Sۙ`lCGGC؏+ 6&a 9#_`KAqDA`CL?`CdG?AS1GL? `PCG?A3C:?џCglgqI#L=MM-_?qgKox&fKWtƏ[ ?:ÿx_\RTfGql >D.v@k,\ ǿd_l1}f/] ?p|x ?{k]?`~>o3 h hglYP+F;7GFE *&+pN(yyu[Vp븭*=QE?^if4TP> ZXh4Y 'B>ڃ[{@]Ž/p/t1:%dyF!Q/ܑoPs i`}NbX6c<*UzInQgȽR1J9"',|Q&Ur .F#q3tV3S6@{J&Vó{|%WN5KsrMÀ(.4| L<+Zʛm J3>̝&/ji@8 QVf^<@1^%rv\oon"B bw^Dp4cڊWzĮR]Pde:v3xc1UaՆ>ꮬ$HNJ-x7fEuVjs@8mRteN$Z %1AP.L%y<U,.mQĆRff t$Y`x秜sA8`U9DXiЮmbC$J+cE**rj ~obme 񃧵-fr1f'*+'%4@-;({;ءV͙l,Em ӎֳE9ۋ>4$NҮ4 ,؜Lc؛yd5Uns P)a=Ƹ$Q,"+Rs=Z)!f߈CrŹ=CN[R.pbfs#eEaKƬa(5h[E5)]:s^oG~nDrɒkyA?3i!SIee+.ÿ|,mA&I"ҥn r\RúKu!PMĤ|AƐZ 7LP'VĒޟ‰䔺Ww3 qnu&pȱ@܌?FLUX}h;zdo";h”-6 + x^~ %abQwOS6-i3wׄ\䈯ap"{(nMWg\"uq&zh{} QsZ&m@idQur& *sʋs4CozA0(j8+Vd3.EJ`wjF6V/M̀8QT ſа"T9{H g.-[ N-g/9 L .tmx*wADpPc%vj_#JΗ*y0(ٔ*UOz}Ǣ>7?~1R& ֚:A>1VExi!, n79eu^Fcm@Io#[F`>6^{+KRc4]/*rj"LM)8 .:4x]P9J"M7ԎlO%`9FV^l7fF+~}iq*wDREp2(H§fQֆCg3-+j˓;.kƂU_Onӣn@O [I?ǰ3pb!bӈmˣa|͸S^Dfspr:ݛ* xgKbרb*e*s> (A5yYR, `FqЊ6~/8G֝4 LH햻6c]p[p'w2`~MS#]66&H jlswc > l?gzw<Է[(j\ OQ` #6֛`t ޡY>6N/Chz<⩨vFܪݧYo@,jatNˠ{Y;RL4GNd>ê m\ɭp@*ě{U9h5B#-/MBNdˍdpOvͷɶM9ÃV C(UcYQrvÙdٯXs `FN՟=UE%Mt/rH,BQQ&Bp#f1?>!'kMf2j/ pj/G~r$3yaOn6 KT^p*t\ SvűNV3]nzl .rzu_03,Zo <yd',o HaUVwd}1:%N sA,(0#h1ѢKm TЕ^3H3uZ/4fKSBX৑cbsuXL"!dhݫ└9d( 2hrbX8xXug`ã %ZgN>0R%R% {Wk 9ƙ2 *9N;ly2-@>Y^iSzĚ T[)blN?R})5g0Iͯ֡lcG|E&11j'㇈_R+B0$q$݋-d8|/OIn e)!8~-^թ %ր= uxR&j߽ juKyI.GC'IDSRAtnįAւ ['yQ!ԯĊ%WI2 31?:8b4>8Un6N4un17f69`YХJ0T۸I,|~urhy twU+Ufݪl5&" ^ pzd㉏Ó3hւcrY Hk`ɚ-= oTND!PJNes!>s$trt+~8Ew֏2TABG^ŰGYw̷c<̐"cG\%?B2U^upɞio7gPQ]k/3S-| nY7h4Y(($qؽwȦ7αn%>yf)w x>Zˁ+cfe؋b cj܇AT~ 3Ool$Jӗ{gNuj⫄$\YrľHDXC$wCw j53Τ1X(\PRU_(Ӱ~ыSnd))Ti|Iy%y;CС+b_ :XBr+5YɓmODRX^_G(}5QxIP/``ùyL{T!Z_K܀|7xJWnAr5,46_;(ni TX9(?ټ`^-†.=[ĎO}uΊѦwଛۉ5~w.1zmyQ{vPRɢ>(͂'~Z;;Id ]Y;^4jdSۜ"AC.1ٲыPBߘ%Ҳd]Ȭ #l4 8(suoU>Z79jæ ;Nc=0Z8v)ޅFWm 8Y1 JѶ-ha< zYҤKs=[32J_5q]RJѮGL;LOw[?w jle-bUa8 ЬZueD 5mrO!&KꮄEpfb ~2PԓHqy6"2;f6SF!'VY<ҶLÅ}upѧXw*i:}Eb&/s#Y5G"4&|Yh4N|0ﲘQdo}O-ŽxGWVAS3|nQW-?+&$dǻ"% $ɒr*Sb7y? Tqɺ3d5֘ǟ,X9%'#yNB-j:ṃl~r枯z06GhXBX0>qoEajAK}u-'٫L7}keФO7,:r8wt'h'QhHP>M gU$ېH>ˎ>].ZeLH8@ #rc y7ʣE)+%ĤhBU)^zGh%3$hڗoOϣW/2jޯ~g6]v(?\ݹ)iӐqFfb@XސkB( `XOY%F h $/.7Ы,;TZ zӺ$ʅF) ~aw5;p/kjeP)5p,UY?T$T,L̛DG#̌Z91T`k6^[rΕPl$VDd/z Za}mDzUDz gD# "'$Hۍvtǎ,픏|&O1Qw1 &n5dɏbXGjB#+aF1M"WHn$]`!ظҟIT0bdB8d5aM$Plk6g>tZZ^s ښk_lDR:@rODU:8Ox5-tѼ[Jlw쏥|FXe2sKy-xbIV1_^:P(w0/|>< -:f+Z ~&j&2 =6|:뻜w{>8 u%_ /ϓqHR1{/ B% _;D~Mf$+ Cv=S(J V VnJ%p4i(ԧݻm vYh/:ԼU#k/ִ[u3 <됡^Ԏ UՌ=֝=3s驱;ycC+ EPT@#_޸;E.^MxktUgvxV0e^ ep W[e~Ox4.dZ)xe,QCKŚ@37EŘ;Yb8D-0xTPIR}f(}\YUJ_;_ٽuRq##i<+iN\KR+=aN0"8mv~&7N5&LSd Zq^I1AfpX^Ԓşc'yBFUW, ::>$8'/(RQ%kQ6?6XC'c05'b~5Kj#;n_!"c5Ӱ=hKR7PIZX{6bT.!Lt,,!u++ZOUYGkV, ~1juB]xWٻaikE/]HRqr8 E-3Rˆ~穲*(˳bzMI>!|s_1x;roI OX6 eN6AP̪w' Lj XEmvHUtm Z%8l9enGG4!>,Íe.CuF$BL+)65E\,ْ J*1d`;1~z>XhmRAj='9gcquDdS穏ic?XƝؾzC))K="[~X Ծ3$&d9Jپw8|.U* Be[#S,ĤtZ畿)%%چ͛'.x]u^u 4>eXC/^߷}/7!|\E%!.9kAWrV*Xn娕#B(ph.v V"19k+Iep?}t8vG7J"y!wrk_8>8U,(h8^?B[ưStO[8>xD(YZ5Ԇ4[_ɍnL@e)M# Gyu΄Yq-6[G 0کafwEL ano3LքY" ־4ct9 Ւ3i)n Ҿ}֊Õ&ilûL^lLϣyUjwc415dN & Q4Z]*+_Yn,/olK ViFKe} kERRLaϵJlX 窿:A+y̫}(~2GPcr)]3htflwޙ?D|VF'ĮobvJZNng^SSq7C}H 38r ̟!Hm훦 E'UtޖfFДroˮTȫS҇Bȭ#C1jn˘70K\ ҽ_YN̗9jЯdA,߼ U6 :RkNPdp)<0R_zNn,cLGT(n{fy:#bs0␵ Yu>"[{d0lu7 t lxo(*@G{+XsN!Bm*Ey> kIq&mş솦6s58% zZ-2TMC?XI@῅v4e@ MhT &S--9ڷ!(ܒ7ռgx# "P~b&w4gn%nG–"h,]޳c#6i/G+D5:YLM>rpK\ZAIً;hRO3DD"NP4Fpa?* b._A{hhXl~0|e.mZiPc2tc;7~t.FڗYa|,^֢WLs|'X$dܫ(_Uqr;<_@<a*N~K9v c&ۚw"t%5;1WeX%O|'{: W5ͭFXmx0u-5cI* Ya9q8yg yO®ZO C?z 3> FJ$&CP_Ϊ&ӆtço [)YϓGwypLýuO>j^59E6#qҝ6%3z.y#Vh1 'f gltԾ9 !TR]{ϕ IU&EqAK\R\[#p{a9Q):~#:*fF5AvZpT* ?i:mтW>Ur'B,5=O&>Mٵ|ƽu{/s Oanira#Obu.qu{}a;s 1u(I~ޓu5Aמ̄&dZGj[fl.pÉ"ќL-7'g)|4Z2Gft~~'g2lD xf8&ٔ:&ۄԦrcO}"恮:O4OlݞndO"d6%; \_)~4z%{rٟэYxH) XT7[$1Nu}YifN7c_Q3( ee/&5~@+I>lzp݃,z8n֏>RScN`_ΌE8 ֱ(xTK+,Xf; [}5AY*ռ]bs|튿 ~"& WCzTNA]1 zOTYt|bo;~N_Q/ºV4Uє8f\w(Z1OD{5E!]v,|dNI#ǙgˏyQ{"q6忛=o ?}@{k܆SR-}<^3*׬l~Qk=X+aV}ec"jzjBA{h'B-H܍xk2 "4Gz|d\+׫ݭVNXRS %H=o=J7ߖL%>Zpw'-Rh8p)7Lۘ@fN'[C#<uh#B5[ qw*I}'UR >(<|Ø%#d͕/:^AsEP7dwUp9Y03Ou7Ak.nsmD)D#\iq//U3)iB}E}!*_fVT}8nsLW~zp рrfr=떅Ͷ Zv b(VuW8JV^0~O(,idq `t\Mwo뮔IVI?x< \1T2RcvZ<ּ Nz<{|)Z/J!ЊV$ K]O*>oS罷4gQڧ`+@>̃^Ăt4'|??EI|d~2L)F 9K\5|@^OX-~iN2v4`c_Ƅ/REf͂0S ~k᷑atW0j `E~KnyU}<}h>CInfl1n^81Yڂ(dud&lxZ3+2|~L@̙j ;fr/wN;Lfwy9Tez@UV֏T/n-fp+R[َfM96ś}3`I[c@A[.@l/Lg0.Q ^fѿ{cc J*>@SO{HqJzȇԂ scFې &ִHC%th_(U3yWXY,m.f/D_zNkCCN?1Q6 >k0I+a:q"6 Bh#[}3Ǭ'T+7AUI 8j3Bh` ,0 -IIzt<5\x(m' W:ȧ"2BrF{PDa"GjLU赣B_⠱9yu.fɑݪӚ*E%kEi0<9O Rm8q!vோR̦4Kѭ.׹AiEPo!;%gVF-ijsф& ioyʭ_< 08MP2#ؕ;q9߸P_@7$ &A_2MPK.1M=6fA|Jbt2}JЭ( ҇haI4Z/ `F%BPDQ_;Ήuw %rž0E@|.w3@_JNٍnW/p폀}h ّ. zI{! 8(Ij BU8iMQI7ޭewʤPD)U'~4鎷+}h aXQ5%,E{!ַN$(jF$߅P矶ށ$)mI cݺ=[pS(EB6.bX(SܾsFvФlƔ8'Yf@0U}B" rUl${zmY}%YWsvq1:`8kh^fe7?@f7.WF̶ 9+'e,:L1ܓ(tO`٭#T dF[Ty:4Lj@ µiDbЊ2ۃI'gy6PLʕp8T;dbW]w,XS^'sAe(_ύr,zV.)mMރ E;piҧlW_?Q<+}@[.x0p#k譤՜aFޭhσFð=jK87м*d!n$2##zo }-RXX=r=yBaByT4\r>0[TeV\E; }'/Xь"+hբHw} #/a^o,mLc>:= CqMyAET% ջ$MyTKSoV-f,YRJ2[T5;dXp| 2VLٷ [74\IE;t <CT6Rsm"zCQ ,F/I׹nK/(C&dꋾwiYTܠE-铘Ĥa^1Ƅ%vwe,ϻ0ʠv vMS9Nߴy& >9 BPyU7m鹍'JYZG w(uXwnhe/;A1;S߉GPbڂh\J[FDO~X&y5vGl0O|x^M1cO%+@y-Qx~nm  Z@hD+%aH$W! {2ֹ/ϘP%/[=kT:`-(M t6\:ⅱP٧ys}_O^҂wX^/ʰ{Q|L]}0WG&|>[b*%h :ㄶO/HW,M@ߛ}1U+`tJ4bu3,Ҋ#JL7@9}&PX2èXFnQUBa@|}_w%E+DK¬f[J⺦GidSұ~(f7v|Sl6y^.2u%3 x7n_ bu 5DZ2I6(,= )]^ B91B/ҧ֎{#p>hzܳ뗸A_T+eԆFǂ#0Nc Ak 1SQ I.%]<7汷 > stream xڌPٺ-k !,!!Bp'.g'}ޫ|2>sBA b`twe`ad)0Y((ԭ\m(4.V9]A2qcW=@`eef233/@ u P98z9[YX'ڔEw`j E459Z]EAohll!HCr]@3_Wƈ@Pr[`a V@{ P(96ۀOo,,/"+8:9{Y[̭l%IyFWOWz_ƶ. cwc+[c27HAS _%2E겄ĭ{1=Y{{_E92i[9e1~,fff.6 4d^%_bP~>sP@?+s ;So02u-~@1hV]f>hm~gLjZtW_' `kɸ@~Q6'?|e<g jdPs8hRtm-@{9MAXW?.mwBnQSGQYzcZZ7WPpm*ͬVtD-lF+I+O\SfkeTvpZ0Ftej:\@+trR# 0vv6B 8>,h\A.Py~sg&`K70F\&߈$$L I7b0IFl&]7E@~#Pt]鿈]7S@~#voiFxڿ(7YF K"4%ԙ3z׀D33v To0Mt#_z7?@&@PAmraYAY[A bAr?~'rvTo5:t%91 { r'7W+ML1|Ԉ *1ɘ!qe E|?ss;5F,#[χ Oޫe.p!oF&)}Dd} V< 迭00UZ7tW,dR$T7`:*aVƠV EW[o5;ͭ,Lx X6v<:1܅kl*"`ԍ^YM#]: ѡ@_r m|)Dz|#_y݅b 꼭~[olF9iQ9kqT*|5r,Fb/b-~vh`/<3ry*$;'1 uA!a=xpw@φ؜lx޸UY}JYhKv?U)8ahj-䴎FN##U(1*enXѷrstYd lJnWE3btAnIx{+eȂ-x,|Rh'!)\{Z10ʎ\ 9+.f*I&^wtl8ng֪+[yI;GqF]<VD:Skq"ǒ@|f4Q/MgK `Cbt  p)In0Hm " }`$CKz'sK0.uūݗu^7uKd8 ݯ:2ÿ.1:Dc7ꈕ< qM(FUgOu$I>R .*^G,0{-z:/Gy^mu=ҥ;TQaF`J˜dr[$jHy6I6;ey]x"ˉNx N\oaCޥjQ{z#ϰjx(*}BꦕD_enUR 9 _dJぁ"0O($?\BbW\%j܉sAM/Яz]A݂N/1Ip ܓ؋iұT5uT,nR%wpP?g[g=ԡY6WᄂvYOa7 )+G$P=ئpZOΉ7L,\&n+f(B5EV}8ؓTOg>UBiX#]1U}f>[8w6!i9ckW^GKM2, "At,8)Ý!Z21Yĺnd'{tX6s-߲:)/Mi=R]{SS{GAV.ї:&ȳz _Ş*Ȯ[ܣ R.AĪ<v^4Vu]ZE1=ƶ?=fdp(VB-cGâj)_PdѻCfxv,NE8P3D#^~U&>``qQRx9 ׉JPR󶫈"4<}R7!h5,ðe :L8FDUErk/?ULtg<\1}Uåzgtû %[m-|Y#DYjosY Sq:UE& _&g'| W[y1(7/=NSAB;1,bjty,DA5QDR$ЯԗupDA]&;GE9.p`/MšqtRƇJv~?{{`h&It=̀MgQHT6= .ȮQ-GtU-Ktv՜_9 :Rų|D f*˖l{rM "le*1K P5–Kr T@C[-Z8gBe {e#6_[w f*엀j眛i审\s1GĠc%Hmwn^+WI_L8:I^Vg3;N5]ixەz+ JAN0Xen= R=!ai(4N:& p6E?zQ*o5ֳ Thoac1LZmK |2yiTecl56[nㆢkxX &+nAx;yAP'ZptZuBѢ~x~o:ϫ:ۀE`~?۽0/T 1JAmj'S䓑Ehʱh̼.Nc"w9{VWơh~CUOyѻ~εaSv#\>%3" W }(:#ظ}J ?I9y.g$0-2J=[9R">gE92YhbFھ@ qP{bxgZntGƒ GV7v!mVEҩiWN@dkww\'4})3!EH}UX]_z=~|oW> 6D][0 ehcVvY cIzrjQ@]^Ϧ8%4$Ŝ]rN5y ce(, ZkY(F o7N5eg}57k,sS8@4yH΋OTノ&n&݀,yrg0Iȗ{  Fv|S}HPa0$kDvM6[bmzL*Ip(G,Ys- S UfǒLꇭ;&Zp05X؄0 EnpJlo|"f2bFLA~ pNoa۫#/rxAr Zj1"%RT!=X=+?&F$Y&:+Nuvj$$Fme_R4mAZlmT-}w %z:"vqNTӿP6> S;(F)9h)q0m ;1ޗCXkp] kaSkDmD %3fF z@TB4mJ׎eX4.H.%|}oU5EC O̅ %bF'Z4iÀebD9;rͶ2Ç(gM P&r/gI%i|GeŤUGm𠡢  ݾ\ P>^2/*J[ë:-C' 8pjSVjᄳ8I ?%xN) $&svd=6Fb$&"Wz ,gsj$[I7V3ێSQ er2GD 0qy-ۇbj|oJоA?F]o#uE|XgFR[bhg 擙Nz>q(K^f 7.Zb.o>nʂ$ Q'$4>{?9snWNmbe:6{{j38qc1q!X*C^\RtNr6.rqU0:ǟ"cEО}e~o)Lpl#WҠ~!IDBO/Cr\mpIqa-qzuysyLXf6; ]0PsO*;us~VxωT1;X -L7[܍:QvoàVp" ׾fda)O=ݠ/*^# b򯎜kFC_(n4\J>}oIf9u<0"c OigH(:g ֵTjDٟ*'فק%>$i,(OP/ѡ42Lt cgnI)u-/zaxvԘvqjFʨOl#W\*R,*zֆ xW\~FCJ[yAUiHB0WPҒf2@쥨yZ5_eg,]QgJdvEJ#@ט TpV!y墫aa/jB9zgT4 -t/L'3vǡ9:|ؘ Y۵y7X-j'ӽ[}$؏{]A3 7eFHسsX+R&~m#91{B|s#^R*V:a -6}QsO¸Τ7))%u w;V0LS?L) u'j u,n76mOdTrSEOň2I%`j&8oRehZܷFlԚw{( lKk(c/JJPw,A Y*fr$BeE4mtlo|X⧩huj̘Iv9-.wt')D[ I(-|ɚJǁތ*d[.]6qE{}*iϪ^.azH*i`ޱHϽ/';b#۴J֨_&1oBְZ1P$lPW[8CC$Fdf' f|Q+ucB G+/yuޏ {TX>j7U@uАu,@HhnylDEb  d'zØMUT!aqeL] uDQ<63=^as\V]`WFkprW0ҸDVx( -7e.m2 vdMLuˬy;}>{72ޟsR8Ҝ&͟ RǙw> IbG!zM}Z@(7Q͸/Rr#13-JSL6Zߵi5^m сpC[AYr"ށ0'B]&w!9Hs?"ӱo-/ղq\W (k>×J~t"vf^}Ki2e9O;O kG)J{ܤХјX͗ gksm6 Ѥ /,yމf'04@ӕA()jrm c4UnL/Nxhw|-4o^ GTbXy:e_7;o?ՍFwhh4tL|~ܛ=*cL VG`j\H*yY ]e*jTcռLAJ%u ~T>,߱+f, HVRThLa3o]K.Vbi:݋I ssrob;"3jfaVmʞ2|̀mZ/~%, צ'e.LRBT }CTAR Хb]}rGvbw^6"Zsy bUT3ʸWJ+vW j&-Za yWOXŋ"QlZ|2(퀛ef&m3=@]~VЅehgs`s7Z٣No*l\a1L/S[xh8fI(}H3 wKgS;c*f$7.xso` ~'^5Ĺ*^u<W<0*p|4M]BmŊfiƝ̧ P"ԦqѴ? /%-<2&ynsUZnMQ<ԏ;IСڦϰbcҺ4e;"ĕ6ce/cy+tQ"y,RLw/qۊaWνS ܑ3ek;4-Ϫ!a?`r{ǿ+ ȡ[3:rj)oQ `{;,Bnw 6|AdtxBt@,@"1wmO x3ُ?Q!5 ~ZB]+@D3:oh|h6۶1qU"N@)3նAuGi nFWv3ށ0w0=oZSD2ќ5r^N; C$b6ORdi¸fnM~D(p!؏|I]r:Qm߇aCrVYzIi]]̸_Eiݽ[~n(Kk+րsr FܕR?Ȭ Ek}fp~t& e.En-narz?=z)2`ىtӧ zlH [¾5ө9k4_zlcij< SkU[`F fB$'HueZVQk"+Wї ~{ApuXD11',t)p{G`ZβڲI\)7lտJ' nbO[^ ԛ8}0$3 DKĦ6{!Wu"uS&wI'6:⧞!& >\)šF=>Qd7~Չq7W[KZj#Kƍk#0z4I覉6)sҾ?4:L׌cM-f;h$Dy%п$͘`do 쭊.<{|Mu-CvN;uNQL@%u4XhHvggyi%}25 <:аO>lP9b;'WG~oMtWڜu?Bͳ)M ~gЗ ]GwR:!Dg3׼Yib腍]r;io?*R-Tqݟ7Z+y#b]nNJzBxBVxEZ2XGu3,֟| =T.+Ʉت%Vv OO{[F߯Nlj>^DF㭦R~j7'(Mx1ۺ^sP!X%mOuQr>A[W"µ(vB6˺j]yz,sLg܈;Km|<FMoB]7A*kpڵTzoNAT^6|C/L{+=? mShSBqL*ҭiJ/'~^żg dhX"oۮ8O}|ºz~lmo6xDF{[bIq"b>(oX' x^b9E:2`N渹3PrZvQfL/ҿZM+qI6;O  T};n4\p{4 |U\`'N" +Uy jV̯BZI2I5#9*ͺS[Wlpȟ;۶~B#D+ |*C4d3"`lMf]v`VBWiG0aM$ 7}Kɕ[CE)V:ܵI?$zgaGǼ+D](GäE><*t/T≲/QjIk^OKGw/:w gP~LI&S Vh~cj4K|A0}Bc\DžP̙Q(Ѩ5H0Ubo{p X c{Vz}>Z#C΅Yq*ʬvԑj@)ܫ//Ox^UpCkuE/E $%.¢2æ N2>\Y iGFC$ c>!>rոaOߘ*ڡLP: DyPlT<+I#Vj&YV7q묠&eڲ:AKUjxKDGacV2r{-vӚAs}3_{B#r=ͦ%/XK?exXP!PwƠp ;>Qb~ڴFu3E&AM⒐)o_%!PMį/^5BNEศJz0槂VN+rMt 5$VxN_=H]xNS !3oő>t=.`?;v0{[qa +evL:JJ@Rov ,  }_2AfP`ʇǹg ћ)b}Sݠ]vE#nSK5>:gY,5|XqST { s yw'Uz"͹-tD %C^=[GM "ϋ%a <VI"0ϖ~XhZ]: +u'DO?7X#^%I+lwz.M*QJ~9"pIyhm$w<5 OLN$=\I8P72sFN|To#ZK*bs,.LxPp"W%,k~8HA^[pƆ`҅$^OZ"z~6[1o[-L5PPKCM\S<fDIx"[qĦZ[2_Ne fm$Ag2D c2j~x>{[)z;at;~yug 5z GXFő_J9|w5f9V`6 n{AF-|jG4c1q3*LɯGo"%#iR:nV Sg쓁2SKtI֌ʾAFD:"+6kOT=*K(SA{1\L[]Q4_~ wLG _>{JJ.rj#S|rSfqGUі M᡽d!AoJB׈y@J2aDr&?$wR+0ºhOa/-h <GooL>PJb zUr퓲Z C\QdfҹxøW c^n[6~(޵#%vEnL{ۤCvH GD?&7mPZ5 1@g=ȩBEZއ-IJӅk|d%jM@3=jK l:*r:&q}6l|Tº= ԭH(OP_|L$uo_edcx>8G앴PEr#+/⩀NH'OE!U-5P9'<2\*{7TXVf,d#(}=IwMwY֚ڗY$LD,G&zub_sDj Eyb{& c=yL+`57SjcP3_vS`<8`+!jb>!ESnw˰$WP|^ 6ԬxhS Tis~qٮI\ lg@Qt åRLmMN6":ՂU&rY'׾5l9zV֤|רԢ (xD6*shyRγmz{Z$cIF`]":#iqBG:ْ͏0(etYxj ]QC)o5\::\ᷤшhK6O#?&\^ʰ$/c7S4rҡvi^3Sç7u# װz^!*pHpvh# v-t}eNv -/g<|ɚۢ ʋ\k)WZ9K0NuՒT3k.[uޛCm x1o]ueMj^i:~2GP=Tyư|jGT8򏍗b4)e1gn)5Kץ U*5Jtb/q9~Xr%c)dtkI3Z|#|C(|vT,ɨc&x/v` lwWwyy/-v ށwS4kVQ*wj˗ތ'W>$;>*o6^1)f;t7oЇY8wf%!m,[HL>AV~}g󹡓WA^^8r6p^Ulz^מ1qlM9.#Cs= N}=4(Q<׵$}lZsOk󲮀.Ƴ3nٿoP/5"# \a.AgmC&O好/uZz3YQp'Lqo%i|xNw>c + uQj=`L*=b8E:EY_?vȕa1g 4(x'p /y`|V$N٪ fux9W{㲡 Pͯ.8^0a{IDL1˶ 6뚡x]0 *+a͞n= i* ]?bsC#h5'VdEOJD($vg@Sz +Eu_UY|D u]ЮQOq"6D݅ kA&CvCKp=%%D?2+oknJ:*mrJ_,VgA)v^=#?>0/S uǨUnc(|8Zgg5!,86HOŒ8 J<42]w#RЬrkՏF> QƵ@)"{MBh9K_ҰPMCx muX@OMWq? *ץٙBK/| v"D_ A{`XՒ.~ƑOn.sR@H) hCF_l]/%wdJt IHQ5}]ѾHc"uyX0g›"Œ8 O2R'2TŌz!P5|(@E4梮 $QO Z+Q@bQsP* `b1g;?Ke=2Jh-e a!gys@qR}B(nvH{ *f7Ĭmqí`rec~gEhHirlI׏;K )H @D} ^y"Ti ]nRܑVhh{Hn~FJDLpjXLD1G|<3q@!TX\Ÿ3`ؓ鲛!WXw,sbL|rk/G@RJ0>s'r _% ^hL5xs:wH'cŞN&[IyU, qJIg 9J#Rwxs-F5O-tmx$`Pׂ "'oֻ_$9?[%K˗cK-?OO0$NyډƓ%lZڃ;2U?S@=L]V-/xJj#4V테,"B)T*.nb>B:dAoZ);ge(MاpJ\{+vac#;Y svֵ\"2س{*07YRc`,+u x߅K›5!,x"UxK;̃{ܪw,7ގ'c'.M+MPSF Ҫ)0ā"s>O80GkINd=ʿ'Ï,.Q`gJmˌ t$sp_l@a2-&֚rd^Rt! Hў֭;[uZOP9 -*Ĺւ*_qYK#2VJ\+3֜x(qY:Mu^W 3;$+-BaYb&>px<Ŭpq,̲DpWtmV>-l)N Lم1A6!D# *PVZÍ1mP7UIG@% \a/ҮT%;w? [ޢ_.fcpzbnfYw"RUWh"ݱQ\8S_!qg+ 9Wtՙi^32"oWuQ+n^!`✒7]T X:.MEB@:{Β<݌nʘuSyaórL A/d_1E/MhJr7 MこLr7yJͰ'xQRmA<j'4*3na`E# &u= w 'ש8w7F{/QY SOneµI8g{w-ښdݣ4[nVx V zd yn$]X.en5;v5~/=e/mĿ->Þv{F:} q ݸX13)TU^ F_@C٣3Zl~ɽGG'~bл N?5ozC(6-.+.Eʱ]m`~t*jR۲@BW۽^N*|Sr̀hFGb I&,=6f|=Hw),6Z˸o8-PsX"KsP(5Ux0O}!o0rħp@Kg~-ayՆczxj71s&)%E 4(jHw_d(=/QpYd*1&XBy`Ңtsj) %iݙHV3&#'eQ,Sf:_SEB EWFI##%@1rkQ BBS?qp!$C?Dh!{&CD'}yVե)AIZtܵhIzɠE;0FQ*Ko,0;@+4?Fm7o%'ӝVпij_>"#c?8xECJpMC}hZzAk"v- ߇ J'|@45YUЦG1~$īq9Z\A_IHw;EXPf^"z]yHɪn*UD[jGki;fl)xP&%Ss7/$Փ0c,wY0(m%raIU4g˲']0V%˒l|kȣbxJ?R~]9//4\^ _.t#鬝QJ67 j,F֤S \wv&Zq47n BPj@pG"ɳV3*I _Gs.fB4&m!Ϥ{ ZBD LPKDiI ze@i8>C <.G|`~ 4 scVڛj .lmoIjbp"&z CR]v;w,|ZKq1m:wv K>KɝeQ_Jy8K0 g^ 5m^jwuՁS~fr`~zsu`Bh Ŋ򇒊.UD4 w; * a] 5A3Jn6؎mУC2VxN S=]ⓓPFP5sd&PuN(F,lҽ Gؤ@ӵCZ2t]5UE׌#dIISKWeQo2p6qH"@L1oP%< -!nc@uY2/GmrJ;Zj 4EeVDr: 2vL͜ZҶ]L$M,FRoe3"Gi@,ed7a?c ހ'U(e?[ *uͱfyg ۹鿍fGX7 *l&sd6N'Δ.l"°!DĭHj3=XUD %Fӣa@%?|p%e)];ASilG3US"Կ'kV) GFY Z!G9]1H2GV2:};oe 5$ɢJ6\{ېt¿(v #)j8il]#qⰰt(-YZo*]U&>m\;;e3oc\˿pJ@Vr᱗KQ{BR-D,ͩF+$4WQvX jqPUBѱhɧ~1;(lZx&$+P86{ ]ڗ]@`go(>@Mi+{@1$s1K1NYuGJ_G2?)ox=l 2-eFmr.&_sXɬ=A^35YTlj YJdUƭ .T,3Y1?R"4'gKHqs~4F~ d;e´[ߢ')pH-,493sgbZ '/P;#Y܌$gޤ+25ړ_PߤƭJ>Pj x\i36rurKS*.$b\i͠ =aG bԎ3)K,D+~dXMMp4n~wiXK;'jK@ endstream endobj 157 0 obj << /Length1 1511 /Length2 7479 /Length3 0 /Length 8495 /Filter /FlateDecode >> stream xڍT6LH(0H %% 030 )-]4HHt"4ߨsoZ3~v;5@z-]Nik%DCrpD: %HGhAB0" `$ #Qfp@  Qj PaW, Cnb v V`@8n;tVP_!XHgQnn.+a+":Wb U.@]gum`V+ f APwtc?Z;_޿AaVVp'g0 @!M5.'Y2;Q`w0l28 :W+ uU!0&ìeNNҕW~rP u/cu=`>6PͯݜaP7_(@ !a\[ F wؠJAm W;DA|[o` B,!P?Q0揌< 0}2CqspTuJF 8y@>(Z`_YU"Eu? 5}Xpc!n Yxiݿ_(9:ֲR`'_z_ݐ(Q_SCȟuUXCݜWv@fw POie*p_ A_ jP+UJyv ؋5b$A57\08@#~$p@Q$Ep7?o_ /u7+fyH;|@(OLa7WVnjSՏȿ_bE0? m;~Qbn3hw$Ma ^EJ ["rdgyk۟W :o (F ?{{kقީuq&'=U_!|f]{ZPl3V?4d g=MɀcI2*f}^">MS|rJqd^9G|1pTL9:fU)ѩ>?`IeSP+f"VQb~ÒųՍ񆏜[D|%H1Eu1CwE)?iJi]v\s?4F0!sONbm3j7 X}c8I'ݟz|=ب GVfQf%&lO ܽz%mjf5 GW >K?Kz+Æт2nuCQBw&T("x;l+e_AANZb!ORY_'FϧIK\h0Ns$+:xj|-Z/>eTBf۔ R]gzO.\Wsuhxi^)W(w#k= ̻L P4&J4=2*oTbVIn H-`aEZ6t7CRZx:=7$SL7hf_t>7?C4?+ Uy&7b1'TAw2lDWj9HzuJ*}r0"!8xzhPG[8Xw5Ғ» X|elz/_z'kkg˭f:^r{vjӬ[ނHo[457SoPeOa7yW#>6ǐi;A: ,ew?B^og \*EE{|}{3[VM[-@Og"9$x;jKXȔ8b$'Žcq6$c05!p7TzTވ|[_#=v-/H)@ݗRe{k؏` l%KXꨕq֎&UvId^ORGr,߇0&E]!Ta:υ>\[(-we5 λ2?&_@?$$_-ULNNLǓ&0l҃6oHqJi  -k2 %h+n.evkHjZ)`mz1;>mGco`K-@ [+KLuO63]4.=Yk=5'mh,y38\}C)sj+ifʯWMup6܉r\q]pFn|o1} VVe@Gg+ YmAaͷi߈l3ܙVkXv~J`P|(m~2bLMAjg o@JAPj:qtZڝT~#ծ*1VōS^Z!$$ܽ|_RhGccSpwl"a3UP löpPg)$OX]riS8k~欵}8.-ʅ?={gmpH=@pgΑ!3ځ4z{4II9!@ˋܣd{IGOTEs` FzS:5Aw mYLc;X|[2|3^( SNkqpy{l6~͜#(tK+H`@ut{5\W%?XQBE;WOWf>46z7uxZ Ao}W~oZУH*>PwH8v|#cМ -&3%_:2Ώ,Ed^sP* t,%F>ۃqn%KamT ƿLrǥVkQ\v~:II-1Il$2eb\b3V_f"cN>jK.6A.gO&fʳJ/ѩ1EfS.3lm@2ۑl>F%|6#V:ľ~%T:5NPaVO^m n>vA`+ $m|Nx2RQW-L4K*~+I6A/DsG=X!|'cۮMY~x80C\*1Yb3:0_$FM'܊[eRpȺazH)#or )=!QZ&hܱuyMUk M9DCaJlk3`u{M+?%Yal_Yr9ldެ 2/~bW@)z 8F>oяKhN;nL(s-ZeQO*/Eo[A5~Ǯ 77%DyK6>PԷ\O+~;!/t/17l%"lSF Z,J ;o/PhniV'$S.k гQ?}D}CQgqEWWE҄@Sbh`A}]vCZ]j-'>-'$ɺc%z;y^'tęG.=8m (=ݯP#cYg>蓓%.o:#-du女fI]'hf)rtD;׽+׏Y3Nq*_z>5`M,bt[]5˙~t{BĂV;|!h?pq\F8UIMl-Wt=]:ks_9tM̲Sslͼ$>g&Ubz_+C}1:NU~/GD˾,:و,/ A#"-I.a\ *gUSPZOphe#k%VR=噆}Q\674bvvKByŪe:.aϤK\eq2'84€MIUUtXװ{`22>}B47'D|/} "bq 2zlnH{plptM ՘㦞I*y L*sY~QC@E 9/5B{u"[;!7~!O'BwTx׊.i`zqyR͡oāԃČqDɒ+<[ߺ#ͿTTZ7#))1mm:y"^o@YcH8T+xfͭ0άpl >p6/] F_zFVȐFg,Q1P5ť][rW^K,El]?%;+WDܥjlyӣӛYm#X6o:)Î_rbGBYGK:L*iʵuD-Z3 W%Xr|V^=pM,Rcl$ h@qg& %&,_7Xj IїtulFbSw›U:Jy10f^w7M#;N)y&\'p132jT"}.Q'UF7xn)SM%b+t(ĊZ3Ah˭1ǭڳդv?sMi uЅX=֏ A[sx |f9)ERo#Оt ZUM-5X>κ D%m,Fedz4Q/nYQ HDOӎn?# l:݅;t }V)l hBp,$>xYS YWCz-HHz4j0]'ϟ;-]Bd+bFiٸYb'#sI:f^ڏw)Lm}YIk$Yb>s+Hݕn6t˞q*/tYN7W+$w7!4M*AaW2_2*_@˾^8:5B0rđv K'~)W*,W K# "3啕ؤ%S9C/,+qmkv,]dpʑJ;d:(ntV3:)+k\aS_sEy@zwnN|m0QKp 犂9ka S }sYgϊT=[1rєsU 9Ơzw1+JD·au$@]^g mD8|*2&m3Aj{ў\a֜\IKֲZ#maJk;UϼT^d7RYZi!|e => WV yW\ol=}Sabzщ;i/8z $o;j WyPsN%Y~;*؜LlO(&رyEϯD|2ajc̛7DY%YT`#@nLc;W4²[%?V{mߩ/y3pn7z:xtg}ph&}`POyP >ˈ/yR'ʶz~FsP--5i}uSsG ǷW Vo3 >`E!JS WY} B?L)O '2M`պOiBT=1uEOG> _%J0r=?DfWe2 =\}A:Y/gQOFb_/unJ-Mdyk\\пstJ>"~F|jOHLQ7q׺anu؁ZDV ^ TU $Þg_px`Evn5g/b~5 EZ! m$;2^ؖ[O rЇ8~)qsf+hdQnCԀ'cB?U:İ[ ."AsB3߁ rTSw>Ȳ?lI7x yD.H[m2]9wfo ۻ[4nG&9O _P1t~`-J#6?ra endstream endobj 159 0 obj << /Length1 1525 /Length2 7706 /Length3 0 /Length 8729 /Filter /FlateDecode >> stream xڍT6L 1Htwt000tKw % "] 7s[̻gk >"xyM=Q?#^~~<0`Tp5)X#f0(@>Ł"~~kO@Xa>p#yv[PLL;@ZCG F[k@f !|]pvqspG~ вv.`v^p @ ;jwU5ڮ c?܀Z@`ogk[[5 u؃! / 2Ð֞` w%Y]5s]`ȯ ~A6Yj'sqAxSAȮ3sC` v*e@??rm~7qV\@`{@=@~  ':H>̑ܲA!>.V~<<B ?@ywk_Y $k-߱`HƂ܌_o?v!ֲR.`_z$_=Hk_ӧ? {VaY&ݕ ;0UO~- tȭuF>H>VK+0_% $ í}#FJB? r @޿ H= kB>_o O#|`$ "sKFfD #He ?S [8 o  śJ9Շfz7$N}?MzwqCT3߷FTݶ+kdɭ6O_~må1oނڥR!JSDӫOٻra$bvKK:uO8,/lf(rehF?)qG֕Nvs/d4-4%&iW>B'1!1 f;[ |A] l1GA>_JIBϤ4ڣƽ06 rR\z4A7> hU=\Il5(0΁^;:Hȣqv5Qc90Z%e4IGV;ND_a{:-(`:;Kt0=@~bA%|ah^ 9Y4SքS+!Fff,Jm3/H0f}A[sb3u VԩӗJuzaW>6}] 9s`ʐPhɟ/̮:|??كZ3lYsl(1ȧoPWӤ"hys_|g֊[hKnG+^v#殚X^ o[ ODnS0`}~`1/7™͈]!QQPKW;Ӄ}s&Doo(8V0;}!35+Ts+ % VtMyY,ٜ3OԹhk`wɎ<9Y5է9z/h팍 zhf99yLlwRfaM'|UfӢEcn~Ϗrq|+nx?7;N4%5L0&L^Q[-Iɥ4̑hDdϻ~ؽŜ[ 6[+([1b}lo7\Md_Dzj֩i䗚4~;QpEzү=TA[-<-.٤7Vpo@n?w{.O0յ>鸘NUg~ˆ*nw3v@5RsC|*RZT#Zk^W}?bf8Gw]gvwA|֩,lϞOʜt_Tr|Iw`U{|@_FFq{u`IߜpOmbs+QgB"yoFfB[ˆ.3j kaTS8)BD,'=˹3 tރXȤ>+m E1КkĢq!tZ٭Q3/`(ċߙGU_(q{ɦw)O,9PB 6< ,c=NӤ->l02,t0-˼?xu9~uw98bJM|,V.U _W݁(!ǣK_/Mg (,jyUn=j'/Ҝ=|ꙸ***{l>h$Ҷs~njC_gΡO :T.N'" >j_zzgBnrۙbKezDbtCǓQ/l" J?ly`tS#gy{.cǦMSrI6WFƷ<R }[ >Uw'RRdڥmCkrjIīxiabnW3eXCmJOtc촂D==xK=xɄQ[RudoGmc,,c<5y"g:PTB(|y#TMc*+k:Aj*g|v&>Lr*&,:5P6ɇy"e\.lYRҗ4Iuy}A"\)W!8Kk?( >xDLBIrwm3J1:VKݷ1z6V};f,DxTDA~K\=kKJvZ@/,g)(s!ioƗ7B> ȢFB:!_*_珸zt mbf߿ʼkMy?E\"D Kk{j#776F#)BIg#L_ܘІNO:>q2m8a`IBJl"\ }K:<=s-mi) A393y99k$'%ʐ}Sʺaw '|g^֊v!8qRM~ juӧȈ(26NQmQ189K66y#z$】ݗ]== r)|L&S~(|E$/ qtB|y6UK٭M{il\$咩 (r9M?'voubBUIrEhֱlGxpN(Pq5t>I2' +MI|a)ɞU-ak[OF% d)\辁Z! \RrAњ^'珅n#Vd?稪Ų%B%06?xUI?+oRyj2M8%g.Z!Aúɀإ~'Io-v $JWSNvy-s6!}ʴK=7N6Q~&#%yPϪPbռWqNv47RC8-GbCpTI}7f6OL:Mu} TCv+/O_'QM3 .~xn6 Z !&Af4 ooOquCȩ!QQ[}6/UkI'8>9eE!͆OЦbCsu$g{{ E5';g^/d%TކRpC42YICy47oryj={59<s\ӆ)ǛfJ^G F1~Wbz[q)RA_d=T] drpECH0jK')!X߽9!kĩN/m@./+YQO&s-sW!VXl "g&rb~li g+Krb@XG4 F;ym*+t:ڜ,ӣ!>Ѥ.`jᇀS13,LX/u?bo.*WDW&>'%OQd[AߔB~q,_"11/1l.&_= s_|Hأw |X^D6zr{}%m!/pp+!4;]'#n{Y!nn;z{{h?eܛ~48ȹ UH޵oKeyMᢋA3l`PILr$7n/'( {t?ݫy]X=_jXZ5$06iD) Kq-mxYpiGivJ~ɥp_u(oNĥ@I]֔ tvRB͈x9\<]wc#_d7h%i:I2O Эc4К.+v;u-B aLm© b+FoOGWI6_i?ӯ5 gaUc:|2&cwǸiq,#r>U?BY?m˛~6Ҵ@O&Ϧmsc1vL\t.%Ks(&F n(J} jc!s4 ,TheJK5rxiG4a=6}z9h, oq5}tvkhPKP`ٴ9eL'즉B ʡe>{GMylw݌]P.OO>+x~ba)N`V S}4 8jD%:LQR,Y)Xm zAN:msI=EW2`H͈/%y2xkcUx&yzVDOndziĨq0ǓI4|'ƜC("wHyc/2Sy\A"|1;M\,אB$MZ jCJٰĊ!٪Uy&A'U4C{v/Nct˵_եEۜ~v FYȄYh0& Ҍ[Ôa 6V&e؝3}rT+5k[1p2G",12 6ms+OWҬZo8N}~uזAʶlŬ<#;E8[!#Mo+pi >߆,1ú6ና׏#[7|sWf˜'s<4WFh5yds> ް,^03bodnkfE8z83T4ڊB3aϠI6EaL!ZL+գ{"ւR¿~wI[zqܮ- w3iĠ[[[w~kK]mLDD9db@F (FXaRV-_N:gNk$Ѭ{c? rIxHu,[@%xF}"x:Q|='ۄ|ސj~mK>ZșZ THӊO+ҹYj3I_{w=Vߵ\X!Z'I#Clख़DxAC;\>5 ( D%iQ#; ֶr2ujB52$1SCRv׿swkA,x)Msn]:ȶ~lJvpd7i9O>j|?OUWxMg^m ahr\7DI7 ߬~LFM8*v iy wmt VY ? > stream xڌP\۶.$k \ww[p݃;<>s 1&%W41X;21pe9 t LfIaIUf6\ ?d"f26I'K#3?6\}g3# @K*lcfofbFNNvV@{3C}k)#%@ _<\...tVt6&|43GS"h 4U.@V wateS3l]큀!h Pe,/[`cݿ"2YV`lf ȉI9:2Էtw770;q}@W`hof@`fW|4YH hW~"f@Ï}6.z6662#'[zk3;'ȿ->Dd&@G+;'hEf [#/[ @/3c3h,##`41! +@c }1[F6֖n>\z a5q E JHA ebe020?E^Y06p+ُ.O>}/%࿹dm>&3Z _ctZۿ126`MՀZWJ8쀠h f 47s44רKׂYYmP KU<~,61kXnGXkht{t6.6'+^/ѿ^b Az?@/_ f)}pArA^TXG?S?C}D7>, X>8?.??Gk4|l(#bfkqZ,??RCdde#ǥDo'?QP~5-fazۏUӿۈckOB@uChjGLY>JqtGo?z?>#۟?\݁5thV  am kq\hwygHw~Pz,ٷ;=!@'RVm & R ,z7A+>{*N.NbO * yyZ7vJf9q D}pյde4h~WaM d6R%B˷p4 cʑʅ+ J;d,5I$s&SZ2C6 -A$GQjk3O>AgUZ$J3pjѥىr~ōhDr蕭ᨎ@c;ncdew;a|Po\]9Yy.cy?$0̷^0_%Y8 鮱VGi&ɽxjJ,N;HG-?Jf`څ] N#0uU*rȀoo/'2[rDY&FOִ݋Eԅ>*p}vG80`bHηW~ w59e vV9ڣ{ɧ>>5s![9\~( iPOYs_d%_~M{ͫ5%)RM0"(]m5iN6W/7Wt*9z.FXGFnKw}g[!^ [k t1fGSn):3jV:J($pɠzv~xnu!iz %*)D5:z·L4r$Y_OphĥlpKAN48E .*Opf!Lw H^fq7Ăp/'\$-/D%%r%d4fclɏMؼ6`;hˇX aDA0bDYıVqMCͺ!f`A)TiHh%7F"-:~|*=:@vW2Fsh/ 쁓FU[C/ΰ96b~,{ ` ;Ph7ٲfZ8CUeV#PL\k獔nMLE-Ig Eۻ] s\NH fk}l+.'vStThFi4ԍTk$edYѲUE.r-Cr1i@=EpX øhi{ =-tbEQx,4>.6B X]&M |[`lQEZlHە9p?8Ӑy-I;XOXygfmA/8}:0YuDLN!Xѱ.b[W6j7ֳJV|d % !Zw#hȀfgjj=5xwCկ$ײ{Ckrٯ\56Fg xUL/!Ÿ-CِƟLL^w`֤\5o4MWFoox8'E(L9'hmX&w~Dc= Mh2S˔~/JO9 .8Of!!Fz# 0ώ 6Ӗ=j'#tu_k55xXRmJ4O7X9#Bf-WJb.2,6Mjd~6FͲs]go!켆v )7`JBkY^ff=iL'0/ #/˭a\~C32Q u:z[NUpjv)?/Unmͨ+̏d;Dr*CV95*$pLhף@csyMC59)eMG,ӛKO\E V ڍV=Q߂rm~aTxh5|}3E-6ꓯ 4ge̦MU8EK'a+M)ex0ibTI~@QvfTyAjbZA` YAKw;6˻|ozkS1,H>˫gi7S/,35Kv/ k\ze#KFf hdt=QzjV蔇oC,rFf0KuPn->ʹE0cg؈6v#>+ ,2k3NqA Up/eZ]v:~+?vj63M||uE5ޟXq5B5l H;]NiFE5_ٰ㉰._XSl[0z>T!U0_m(kB f 6l9+B M="-8a+l(ƒ0,Ti3IpxzoEO5 ؘPju=09Mhb!Xa1 ߓw}n$Q{Wm9X _Cdz&mqjcM뢱6v ŧa&UJ3{H$tAuFADžQC7pZ 5Z[o˕XV:jN}$Oy(لHF0s5X|߉yDC9 ˫*|ș{NcbF2d)c`Ja!&  ~NMZkq0`oh@kv} R9ѠJOyL*2gJCC4ilh@a|AE8\< p“]4ra  [|-kcKX9s37 έ8!SmHxi=D: VŅJZFG{~ALY?B+{Af[?Qو S?2^Z&8Zn<Y(a=N5]鼑w2py[x7 Զ37 :#>ѵq}{,Lu>@اPpq^sGH⪙JE,_hB:Nb ?=O`]ŵ3oWJ]l$Q ?,~G/M .E3;7]%uNю15pJgzH˵y`m yE|go+Rwav;1R߅cp9Ns>(aQL v: 4>T.BF=M6ItFS|V,&҅+l+t߹dzm9sUNM @+gKءۭ,slfhJ מ$J[0#v:[ 3+&m |h r;jr~U"AKbjUv]w۵,郧o|TL؟1 O o&jk_D5 0]Qg)07|h0CGNz -l'(b%XB wǃE(9j1Mr$f qYӣ< H&!LI {Z6WcF 8WyO LpOſ%Š!M5tvT3$a 2#ٱ-J}U0.yA*~r(d4tI2/`)9,n#\]ʚ2]tpR5#>xg!j4#Q`Ե  '^C}+gݭ6{x Q3D ]jEF@Xj5!I:]RD+mN&߲% :T=~i6tIZOJg[w_v %Nܰ92fuu^OFs}0ܷ-%4)|v!d>mXo.lvp{eց5rZcU-\[m 4VpnwkQۣT&{*[ciD$͠ G5`O>m@RBO] $U#n*g4Y $dC+}NLC [`֔@Hܓ]$ >KYTd6^wb)p٣AEt &4]2\lE)^c$sxr`!y#ʝ|(B]E8Ij*jz0^QNox+[OLԲFD bl0qt93~"8x;=X(R|tR[O3|A,nsEQBsgMm 0exz/ cŷ2l0F$./Y-呧tztwWa.}B2ꢭwMS+@Ō֏Vޖ\z\䜨d,@\ 2RUsg9{8&/_]-̥UJ Cl5ݕaCSv=v ]!82zͺuVT$@؞ywD 77HhZ=8~b#wNfEF yj: 0pb /_IPĵD1z7"[}AuYDL;B$]"ȼo313ܓF[1Ȯ' po{UHy˞+7މޭlo)3hɀZ0 axQ ˩=x!Dz ar8pH~ !;EzW!=j!#O9nX:P\9.KRduSaK(4Y(^֚qdY7n'įw /^oδҝKWEߠ+'T,o?ˤ+.GQ(Y:#BdtLK8X;.g ;s.~ɼt[ZrS#Ť`Hfȼ:Zb秊{?hY:P:2Ń_lά ٝq$2P i*Ʊ/? 8:ǝֹe@%| wE~B;;g֡$- R:Чvz:Y/B 4yȪ7 ŨK+V^ygd1&d;8_КV!h<_϶q-cвjW$審e-NVR (sS칆_2,I'TEՂq B C`-ճ}0"bGjE}xȏ&ȐR|Ļ?xJJnWUT{'|=)?f;ZG~0|stosYS&F:f{5? ]1lX=:"!^oڵ*L]5'Ƹ! k0+*g`1sv'|mwԢT+6q/yh݆W [ v}z6o/3ς%{:O'-s6ݶlp#4@ R/W7䙢z"\5JRy}87BTO[:僧&6J_x"P-kciWވð=Wzn6v=WtzBn;HҔ+*]VV}*at] abUm YC| Z̽5LW^"cڤYSJnQt¶V)XHلk94&~ٍbA9MTFt3#>ѼX1~-A3xkc5D}Xr ["`C8`q po7:p(w;}dŶ#hK K*+6Xk7>e:}D0,>KzoCI=i)j?k<(+#p1Z֥{Yfe+g9&}tb"wn!|,&sq~"+ JuD,)7'.s1`8M7=Յgx'/@DZɎh҅J!]k',quPx) o邃܄|m/j\h@˽5!w$ wܕzL6o[ zDg )IMQ"ߋe=@XMg02Y M|Wޘ+O=oLIZ}T4q‘6"Hfv-<;-w u<R~ibwȪbLoNBjVTr :.bR>.uPE!M`w׸Faߗj7z: 'ftڧmNmߛ}&6?{|u`v6ZϙH~L:xAm}&Z ]P :b(k9KUjaPqIxԾuZ&kM3Jl,@~Mm?7)|J2 GeO`D+yPe yxO8/ þz1ԍ#' vYy"QB;]USBjVf^D(3*~]mL#f)CE7q0R2@AL8]I߇DEA |Roq!αv];{2 w;K1f$3cZ S5< 륕A՟"jz5H!JU[]/e:s=SШY8PtDF~UN~K{d$]"]aq`]sE@,OOWTyۗc/["eEj䉚ӱYYPI/Vrw}R []_\3lf#5sUehbpebӭc1Ad8=ueˡ.;2QwYfdv<܌+$6dݱ8Ԇ"<{辥E ! x'b gyVx\'5t\R+P QPSZeZmHWC_/YFw 3jOxJ#cZ{c͗ _9:!?ciDC9&,FP6f V{7O7vOSVrcC)m{6Wt92t5əu#;wZ3'Y 7g.|' :+mrFKX>P-ĐW0a `\cE߂V.7þݦi: Ly>jhC>:Eږ=Hv+)" otn _yY|dh4[֓Cŵrܸs(cfɘwx ־thW 0#_pցvjsRw1BjN >Uu+4ʬIPX2|Ӄxi]X!WL y>upX9zAHCb |ۋR`LI8%N+7wx~3QoawQ*;`ށDÂ0LRL˝xUc-!?3K4˷faFV= >/q'MrA?l8~CD”ēڍFRO/cA"6dLNfZBn0pQ?Ѵ Am[S){mof8# iRͬ&T:)ljzz_g4!dB9,X7 o7x;<9x)N(ee \Jchu /I 2I0% GH&h!i͇1 ne˥r!: J`0O BO(1h|R. iN89.ȧ`jaS mw99N]7ЗN~93aLTCS||YPhE%kpsi %UN~R+.o&nj# V._MF_as '0-G}.EiPC򥢅̈́a|cX eפtj8tH25AiHj*QMrWo̿blb"|)`ld;Vk xWd_ˎIS=Ɲb&@uXHjX$2'E@+B'K~[8 Oe OlNq=\еZ]Q{zj^.N}ߥ>UTIGq7Y-*Y%gN+z>lS%0*Up.b#ŦR/rs6ϲiY;OuNd| Sc'*l5W)^<3{6E,a; +fv3Z6׊:pS_KG DnlaB9Jb;tsX@8?~蠚}gĕ'/CV+d(%Ꝟ!A=6& H4GPVQ ze{~O_?q!< mŀS,Pgڥ'lH{>Y)yhETz~ gf jO"MaU;AcJ+BMZOХD,I'mG`;a~Bf2%.$ׂW >a}viƻj;F2wu2X:oj,aUzY}eD=; i)}6@(vk Z9vXkUUy/G#w(?IP2x@&Ux'7Bɇ2!\z~˺8gzC󠮹g؝rNMaX%a4Ȯ4.+A7$ӱFlPzQx eO ^4%CW} f|kt-|Y&f1~{',!7a_p-Q\E U_O|\$oI2TX6+_sx3l?<[N1o8dV6՜Akfԝ8q{“YxwFaQxt^x8vAҘNO%<14s8u̢5kݶxIx#{ C/|?8dXP,ZS/EiNo(He^<\w ^vEuf8; *lzECݏHZ9P~n&\K3yTO?$¼\Wأfx@v삤MD^\T2r 3ŧ¤C^7/n>{2CԐMH4Tpw;BѾȬ7yI~7~4 \/e;/t܈CC:t;7\6` B#8<^@¦nk%_%WEM[0na.ڮO^-Nh%&Sgw/kqǶ<{NGJk '(̯q9 x/RA@ܶl߲? 3hAHl9:qbm'Ŗ%>gSæ͏fݮ6)M>{0'f[g߭a< LP&_`)z۹ m@*"~‰JyK^~M3IK2A~OFgEu'07ڑJ0K&GsSuȫE@ϻ)\ͥRփK"%esxqP"*2̖P2ԷMa |1(~ H#iEK][(ﹲ5y*$4=BYJa{OEN'27 gUbAUL>A>7Gӹ> gWH^1"tO is @nWs\V](egy#cadfjAܑvpp՘ꄒ8XÐ[ :{ _,Js` Ͻ'&|H+pV3U1~spy'V`pѵ9 v`9۸Z v'Z]SY+kwa(vϣ{ \6;y6?fe1$2( /?)rE; =r{p tU"kE9豞WnR[MYHmd2@'?L< u^ШT̻/H~'s?fG@.u4vvi@q2r[1fDŽTjUVetDE՗uft vgSb;7܋hr,qr[-pW-#3(׆h-͵ &z (N2Xs=L__e%F0q%35m&\du7..g7̢]F@eDl3WL-*\RB=Moa_9F>7"͋Nҕs"&yyr"Ȱ5ڻ'CN+l7r8Jo#2]U74JQOUYl߃^9P'f`AQq@f9B 73{p:FQ&M}N_=+׌xzό)7Y`o_+ӢEQp3T}z )@_:?-gn'C2%] \Ju\lwƱ'@RsŽLԊrc8q4@%bre<I"glNb3lZ>NP3R -ڥ9ׯ\o*a)AAgwLEҝm6czA("$܂N;F[I.tbzAPO`/WaY6ӧ7'ㄵwe1R$}>q!N?7L1Hܞz#2h+e._ܬAF<ۀS6Kɒq?5h\g,FwA5 ~uSV@n^cNj6Y۩+Fv/3+MY}8;LpSt]g~ nDKNjuyv?C1 PN2>sXb)̖K4C*hX~AHlzȭ1+CZV +{Dt'N'i.ORߪt$%1'$a$Wku1^8"0 Y(Ly6K_f'#voCP:W;\"򴡷/{ ͉,WB0Npjx&!ymNy+̐ʏLB8[2/.xtpITJH=ǥ5eYW 4uKWPb~kNFAZkx\gȲSRVSvD"$z|X=A41HaȎkyQL[_z,)' 8hCeZ$z+ 54b$-kWNQcZ0MRwkF䰏9TNk& ףI҅J频$vtg5;a }$;qLBdQ)T uYlR"-ackkBC/+o#1̅z{R $5Ua r,&+u}%LyvhAuCJCU_CX*!O Eis;ONJ}B!s +q>f]="!)r™Cm 2AűD) /և KF&UUvQ<3f)W6ٱ&"G`'Hj2yUUyVN iqdLvsX;ejDIKA*s/l'#s9Y+m|h4J :dEfUz7֑- uyRfFxcj)%,`;W5[p.|g'-!\%|o&xIIܐ޺R Xblk($S h1: deWr;؉Bn\t=-'9)|/84`Ҽf qdFI&=Sg)d*,~7'i ^꬚DlQ*"̩&˃p rZ1ŷ{+6=Iaw+ alZoyTCd ։s/t 4KzW?tp#C5{?FRd,"3KWcNf3 OvznZ*VwB4_\Ͻ0$2à[7oB$lGS)ڎ_ &^#4}c2;엥E.FNYBeȂNa'dT]XƠDǓ_m{nb+H*qG)&-\FV,o̗k,h=ej^,o'ʕiWI"tj8X#%?L,^g%j(^"!:kPsժ+f'\XS*zgP6hy%;pEl ]$(:M)(p!W;sAQ6*4> stream xڍP[-܃Cpwwwi[pww`݂ܙz[kn2be:A#k5ȁ @XVY L/9< a;ûLDPr02ٸٹL 2;dA@{x2akW;3S;3Ww1xIaF K9bzqq9i[RHNcbe0221<;uWdl sWNsw,9w!7V7g?_9ZZ׷2t❹[ k 5U@#3GJ:o t_Xً M"_r? T7120} -/wfZkLl};;}WQ#V;R]2 ޢ' q08Az?7||d@o 7|Ok?}Ay CoNBT=?໇ÿ<~]kq0 /?}ޢ@ ~yڐ;6Zϙnwi*V}Gi_O9?|Ikn/a[&ΆGj86(c_Sh2L{ҝZz #&!Y*,ZCqʻ s/0̈B5s&N RGXVJi̶R񎎐lo2Rzpd;=O1~7mcܙ;SWWg?PަdhQ~pRZ5ѻwdce-0%X!aoU5["~r\;h7Bx0#ciW1R5̬+LLV|7K_Dž@ ,f\.v u| &x GF2k- @J-kH BBel!6pcL%H=j88P݉HmV$ oOqn!֒~@Ϭ֠,os\:7Κ^=8J&.QgkTſFLNƻB=w2aiJ ؾ-e,3-6H6F\,3Y\LuQL{ƻqNY=M{a;-C BU`o g溾JӦC`wQO~uSpZOi+qy9N/cnMT6aW &xY$~pDaos9.@ 9Ǖr û3ga[~wcQ ~F'¨_9MR jٱDu7w9`:f^xb[{rtk$&ґ(mMB<|08f݃]z 0Hտ*WO[:Y<2/VeM:0TS"&u1 5i95EMwV+윍4Ɔņ~ht#TVbZeKgBFJ:]2PPCgP4i8^Gw>ٔ~hjtvԩ}@6D>ƼvxQd%iҫVpz ?Js{J!+""ik˺R޵v14cCt=LdsJɔ;d$ \ݻ[fc؃iF pwyBǸxџj*0v`9x- /ӵT/(PNa{` O|}W6ض]8e'1tm; Knmɥ~ qGY*ˠwx~!(hަ sb "&3{AeaborXt0NF`zGyy-IN+#k#+k΂3T7:$2%޶! Yhψ%J>jCX'RFnP3l@7tWkf㓉~y vÎ5Q&Ώl*&Vyx,a:61ŵ]͗{kBu_6щ5ff% v j¬wԳȕ~ޗ,`"Pbp-v7CnKBzMRIf3gxKԂHݡʑgt## rfܪ <4ބ N}Lwǎ醿, >[ Ίғ, +BM{9PH E$A6fx;91r3[NteGFhGeԶ-*:}8?1(N+la3b%I6j* 0Xd9L[zNZE^ |g3yI!Dy8eb\@fbSѥ0?>uJ S7 Njȯ+%}$G!LO:Mmx‡+ Q۝OĚd_Ic`>OHsSrpIqLU˫4˯^]mnPkKd!4y١!9& 1.o4h|[{wJ@Ryl3os^04y/CƝ•CO+r vd#*/7Y(Eaf/mVST>d; .٣`;5c#JoXb}/ ^5bCh$?%*b=zS[xr V9k$'Pwݗ;d->sVn˖Oa4R]l׵\!U6t"#2N鱐՘.3oxgmgčgBKROc$O,i2^`_[V衻]sub\k쀔Zv]QQ->dAR">u`FOmnLk]+s sp a_Q?G9" Nm@R2%]'Aqpk )jp䓩=7*{YF~ڜR3 n))\" | plJO^1N)>Ǭv]tpOYH8 Rqh!ӱo F)1R,r"*禉/N//&.y26yp{~dNj:TC} y!ߧdS1boz lT'XqK~SCk0iρӵOUO/{W&7lXVu"i]ombދV j?lފ1)A< |S ܱ|Y@*zBFۅv>it$C[0f_)NN: *"LP"Vw~K-b]<W,`g 2X̍GZc*t$Ji2+ rb Tq91Kq y,P-3qO+Iٳa.AT~Iun.>rNYj~r@s* IC{A.wU`r4whۛX De8[ɸnSC |(6:z$6M;tO"zTmJ7:Ib,^$gۥub\a=sLS0Mf6YbۑjOkT&efXZj H!Wy^W;KYrtaU K~J?-2.D,FC0ykJ!*.OUkol0V>.v8F>6] 0FPZ1)߂&_=ÏmDNh7Ck˹^ mh&PŠ5chKGp:Ӏ8:"QrT+Kbw)D\hQVR-)bpw7/k X x·2qk5yc5'gf?Vq۶^-"6chFu(ƅ)dqGۿX5s+tHvYڤ=xC݅p$dD0yg4TFm$ d;x[s>h6 f)Tbn4;=78{R. 9w+XSe0,X/lrPeloуoWy+;]>΃CR 0 E^z&s~@oWglkn'](eAsG2e~3W|ui`?3W ێ ؇0AJf0Z(7?40$Lb\zd[7sMrG/͖Sۺ(W\)C} WC]/3'Q:n>JoRl4M7gLP+y'FFms "&@24/=EԱ+qѲ4sGDw{!YEz0*O_vs,z&  &[ʴcy7CE!jmM,Ki=;6Q2)^}w RFІX0`D A4cSĊQgnPoOؼ.ʤvLUOFaP&jH,;Z{09DHe/ɛXA[ %p.83=:j&Uk6,4(_r_? hl洞NniQiw<->.~/pwjR#܄F\#}+ =E7W' s)`@qȸD=*,j+ٖ(#T/e4i.E {qxFh*AuJ(dcфת,ګ:D(tU"3lVO`?vN$ek^BχhKe⠱d*o6hzjfafI~ѡ6i)7@*ʏźJͮ&EZΦ>ڵRiAv؊_ eJС@h7~wzN{3^!WB[ĒMi^Hl2O;[>KmrU%D,{4`nUx¾АŎ>'iJ_G&oaWSf}`J#6dc2ӘQ_DD1 2>R2$PyCcs2LNQ1gnBybtn i4 S@ RgG6sc*XnYΜHeS'uN`&7}_2kpTU&*(诽큏sc#A̓O0wO1ЋW.\u5X7uk(p/q$=EZv v̈L3# nW G3& :>`t6 "a)L,I<)#=D*+y,v0J,2^yf󝦐Ǧ7RB.gp+1suW6VWxeҢ^rL:~)4XQ1Y8Yk85*qHh$rQ6X5݄7gzT=BT MeTl6=bEs= Zn^AOʿJHqoI:},Ӗ#&OLo >R,\*R= W0SC=AXa8)% zV%? ֭}С&Zj w|'Ic斔QXE5ٱvasMR1›$HL1jaX[##ȍKo0uL]M8ھ50<𧱱7)Ij#pW~ӬCK/ R^9[DyfY!ImOMv } 3δ@oǁHjF7b賴U 6ؕe1tMq̗LB сox&,CǷ@]LJ"-)U}eXVt p@ERڨ[̥S~M3_>MUP6?[f~TW'\RG>PYNYoZFEszءP@knzq?\%D5q`6E6}FJ2! S{iviOY"%`` ,X}J`ȩBܼӊ{¼fiG܄}xnݑ^7uͤikyeL o=uad8]Nw;5f gxPHWy9=:CupLۆf!&^yU;D; wW{UOcfg'($Wyj1]P,GՈ4ץ_&B]'˺m/89w>][)Sv'jD| iقrR[hhfeP􀊔o^^n4&¡P%tÖ#B`É zX%'t=m9 a#]Sư3YWRiF{mwԯ5"[K FAekZQ8p!e `)IkInL"QIH)Rļ&$؀L+txOt0߫iL 6}|=rFho x${a俰~Ƹf}{Xf8#FP8},ַa6mV@wa%q4%1 f^qYVzkoR^>qib*vxwt /ˉuLz1 ȧ6o4`yqSȁ-hE)]DpiZ<|_ 䛸IuK;qsDD@xaߘ JW3 y6O*uy.Z<(ɼ2R2-LWf}{DuͲ|=JmuYG24\(< w{VK0X& v$ ''pjx O?O0ynS0m'9A$sJD5kQ2U,VaU-.k9'WǂgDϘq* +c\8x2 `Mz %s3K}|}% Srsy%fjHlhdtzHv+gvFr1IX ]ԙPV1秥H9D%{S*v%9:~kkO]MS;*S)Ǵygae7ԍ"mwh Zm  (5ǻ-Ho&{(!뭶&Qv&-$m&‹nT 8CO YZ?j:Ϫ#F$0l.e:OqGeojx #(ܾ*SxtXAimR :En&W$_62_T'@3\$zXX1ݞq|`3 :hⷈD8Ojnho )epnf3ݽCW?D~H |o >UM^=r/'^6I%)mix=i;w }D)qbu=8e8GAU>!XWSJqFj/~f2U(@Ialv+NK>XŠbTg嫙ORNgT/%f!KБI?:?m#wOٗ?kbd-b[Q+uci_$.U ϜD% BM|ZgSjq;H3iISV^ӖM?Pݗ?wf %Rhtv9 _G5 B:$#\twYgD$OPkܡdg >/Bq*&I߃?xN{gReK!ѡmtxMMr9"\Rq󍙩~\];=HxEo ^({>DV`c*yO5RDXxȌA$BHFqɉ}^e_czrɰF-( R[ܫ@{?e6\>] BwDJKCh%z;]m;:W1hmb#:g>L[)G ļ]h fcfXEPAƆ.4;SrN?NZQ endstream endobj 165 0 obj << /Length1 2025 /Length2 11413 /Length3 0 /Length 12659 /Filter /FlateDecode >> stream xڍwuX-Vw V;)ݥC-bERH)s=|_5{kv~Vd;Z@dl@!'r\hZ6P;4z)9f6¨ʎnvNn''CttHۀ쀗W4z)G'/+k(l|0$!.6 s9bdnt@^Q u`7wewtcbx@W; U6@oqh-k׿4-.`g8œl@ 7Yo+89 @69@N^6VK;@UV e;\a6v0_ɛd%buewU%ǯ0F8!PW_I۸@@{q{Ķ>W)`7'mg7?, @BO5ǯM -r2qrtXJXB`h> #4NNX@l~G!c \l<@9_tvtM9 td X-eIIGO  ;?`;_X?B`gNK&`ލ@[+7'Y7;_ s{;80 Aa BbeW氱pIMo'fY%ڿjq5-:q%l{W#q]\̽Ѐ0Qq|8a xg#UttAu|_C_$x"A~oqrqà9ba8upEP G;X?ceݯFqȿrvi7Vo>l5;ئֿSend qa ,__{Vo\?b. ? ,CN[Ὼ S!Ꮏw2ܰZ=Yh'?ha qYq9@``){K 7XпnM@G7*X;MvnbR2Kiak*CDeD2X~[AvxaQG"*B(gR^'WbR#7{Ϊd{LTՅ;#_v6M`xittWَk63+0.; /亵nW|(kb?- :ak4;XZvxB4s,F+TK"koq޹|S'oq';m&n#Uy-B@!5=f/&.q[/ĴUn&3t m PN.1 tהa/8c,@sϔM!P碌iWNWx'KbDCqD%C+h.t>K&He'56^dF Fߔ<.2/^mHbU 4HE9C|#R}>^HPt8s9zNKːx_$[x7FXN$ׁ/uMQzU{su#bo6 v֠xoy8K) adW,*y pM}Ҿ0`''dO۹~V>SS3E^ny[qX: 'i'.ӫ V5q 0hݪK)saAN/BR}dP: ٶEI^CdU*k㴟*Rm={4p6MPYРZ|=6 >ovDp-|l.q{I8D )+(z`sүUAܫwG}W \,~"%9S#&=zfNӫ*ȳśʺxQ#c\i3\D9,Xr1/u{%A *|FER$P4}!^r?9J=| Ա9lv]4w|Wg)8wq{`gq{1Vj%2t-3+?'Ǿ_5WזxՄtn%SNc'3ql%cJ^MzRk{Ol:& Cvo f|<9w^5\1vJw-O;'ek jgjVT %/eyt0/qrT$|I9AqۛZPY2WLdymd[*~7SḺ|*'R-SydJbW7Nj40,3pݏL;C`=gFN\zS)긗Y^WK C @G3gj{IUo{piڰZʷ /L&:L[K4#HHk1|k~:k2ߌ4Bg,rP7#Kڰ ,svT=AEq?CnjV'[/j3wn2u^Nk] 4l ^]̅NKqs 8ʪFx,nkBYs KR oh_ZY }_^|OQ(9Ɉis 8)oHr t4~A`kyˊH)wŴP~A̳tW{/=;I"T 'LGl9h!XMyF?ױZ {ʘ>6615rf(/L },akp'S9jҭrLR `ÜTeCpWjX 6n'@PwVd\h܉@G7Q)QLIQ > 5\<˅v>9t&W+rTS|Lli8*G/.E|z4~|z[b’ TF({pD%*Zk,&$T.R\/xJETn壛rh M x%܎d6Yc<w}_z:3=oZtkU.TcdC^OR152ߌ{{7IE{cC3lWFOH,LD$Dos۪= z\asiKa"m?Q AVx?HfӇQvs/|y`C/5)r#td){2dwp~Y)׀N7UXMmP{q 6i$8xB6_%o$(YVqDaGjY¹>gQ,Ԅ]7-o"IcmP[]pG/ .7;~qY۫n~^> ~;B=<|ڰhoe%eTi A#{9xljG[BC?lEݮċdΙ٥AbO)U8vC;x1&5䐈;Q=O@{1ANocFΧӣI.Rl{Xg,dW7vneI唵.Όp-\! Wf68L[@3me=gdIMN}ԦEE< NjbF7w<ȇx~6A%TO Wsr聂_ kx_?f[cV5޽jyV*!M&R'䊜}1)y'%{F#`_ ^|Ft@JU$9y~yt %$x3j,sUv$kzy:"~?y,NE}`wt{]% e3@Rd6s)E,^gOYwCZO[L5ql5e$ Ż|cGK6x2f(zYV^67:F, =γU߲XK(V +˟ ٝpo|[S$.AYw7K !H0'Q7<^_"ř"h> %B]yֵxkՇަcy/&[WHj&&Oego $dCZҒW\PPUB!Xdr/k/Ƅ+~( #0UdUt/yGJj6mi9>s$͉pC#HHoѨ2hdY^IR+\}yr x.yM*CiJ]E UƸ`fDw'ʃ<{{LQ!HvԄy,gmv@ge'ꙶVt#!|v~J@.gZTB:eRCu=-j alD_CqV}s}'NC^?>MȠu7{1.y"#{W$tO'uoȫlٱ;)~90Bl7QBh:0`0GY`cUlo},wJB|x f <䏬,|\(2u;aZ4wd$; YJaE kzeTY%F6kNf>(Dl+nd@+{X.YSao%䍇[6BK8W6b1j ؏ 05cv"dE>O1UTLF9,*ɓcq3n6=gc_) G{znRˋY{3e -4(z$+Zr3V 4[TR ㈈*?w̵?_.,T9UѾ=15R&+eA~\. m+qnPDM[-ߑUw踮zȬ칷_eCBḇ}𫍍ՠ O* d'K KWC,Q)Te }t,ݦȜWK:3rpE0?&Čk[T*ffXE)t3>LPWԚ.ҳi"[JyLO{J #(?&i6`7ޡ`|_VK.Š` `M{@x4m唊}^.>bpPCg,u^2@רVG_Y,$ޛ(BUL"t촩hdLo^[gjKKNF@@o{ "ʹd9G\j9Zikb6EZ!X^*/`U9}"FeϢM/t1l1d>U\I#ܬISc*N<uGCf j@nbǒ|V2_ #:Ͻs" 3| K5x"%JWʓ1`SoZ)>9(ǩl|1-[*GSv!]d}ڽ]~iY4a/9ON4(rXKWyӷ. |+q挒-}:2.T+ń׸(`Tp}ESɸyWKe?f"'Bi,*ǮsZqki>A/,Cϧ_*Ŗj zT[j %8@jT/8 "&?lZPe +ҟ#f5蒇̔[LbSMhZHt8vS}kG7gH˄Љ߻ďTڪsֱy9&Ww A+w xhVuA1 FCݘj S' <&ب[CH, noBrE^\{#]jTk ?;1-hp}/$M>/s`M.`^68)]c.hVoTR!vY ?{л3$OF;< U l̂R㉼f8Ÿrڳ°0ŸK!|*xz] k` Ivl"{՝&a\{~LΤ;y3+|RK8I1-He1h>DF{OZ<|E8 MTc#ۍ̽C%kD3IZp߳ޑKx7LCF#BS/iSXʌ_<`=~.%C~YkcW[%X>;FR ͋׻v|> he mQ(ӏR\h/Gݚafٶ$yMC8$5yd?]>qbQ?RDN\uA.SJLfG\YWP9ZqjT>6G)_!95l޷zy+]S5{5eSySߏO_pf'R`URy%˟J!Z_5Uoha..Oyot>@F])D&̐bŶT!Qy ~֮}ThџiF5#W(|A ۆO.ctЛB<d#,2Bָn@M;m$vq` &V!&b4OVuqmcFރIDL/35qV]5 x!QaY` lQ}z+1&]3KIYp 17kk4рAG#ihlqa?dj}Z^7 _dg B%LjB&OggIt;.q=7Hϐ ]I&^, !;O^GM^Fh.[Qkg nO 欵!n25}E? E-{E^'ؖva^h^0iE P!ο)SI!72Nv?٭?ȟ ~Fs0he娒DpbI0f=+eeuܻt|1f|X;ɢY*!W18RsȒ@ ~`S3$1FGgKI)lʼnrV8&/ܷ&|/x'HXU\b]nʐݸXb0z:&tIjVj'ƱEչ_WVmۊ8e"ZZNi%fO^[ CQ$NkvdnpJP35Y+eQFMAy^ݬ`Yy2P}U$0V"{wr N{< Wϝ! w&ҡSe%Ϡ>%1э|sD^DwĮ/_=A"ڍ1 >^;{7?FYsv|tMsө[ђVd&"=u/ݴ ^۸<^+{=s)̏|Nf6Q䙺L;qmgF+ L}a{OJ$߈ س8~ϲJٞir|K*Wu% FIL~{&;l]vgY3-R,ŀm{[J&jC7rng vٞ2.|dn F.tЕ[y2p[ݬ޷8fYC29Q2nj4BleT5KOjI]NLlv]K>^&g9+q־,j(n:8w` @EAћ\;Wi-},½PeuQE*<+ Nx@n.Ep^ůloST啑ݹBL8QIWJ7vt4?؟ cU51]7`/7K՜V,JtُK|_ #73 /uF]xtHCE~S%1Iڙ x}N`J\ɧM¢p#\ZM?:6Vs@{a@|[NOxH?TzP8lf v9PV34`:3gqҊBLaԛowBB q z+s<&qt!>΋s8 +V޻7'?R 1$9z/`Xa& Ю>,"_5 8NQ;} p%c,v9|$`Ǝ!پ1[h)Ky M״0|2XQ&rcICp2mvJdx4"ݿDzLbjwoP9J?pwueX2]q`W6&zs@eaD"M4yq&sΎݭJ8,qb9>$xvt e-j,Fm'|\ϐbх{l'{_9Rths]tO| bHaS[`q%b&0[5߲oh($hi1EB]MksSba{U5bgXwn_Ǎ,ƒcdB̕،fUJ|7g"prVegq\<ŕEga lՑBnK#D=- &_~%33*yX8 ??=L^jEICO Z:3o˶F-iynkCSdGe{hf6Og@ӆ9$ap|iH'4\9:l }<~ $?qy&+BI>/&ԇhS9>}n@rSc]o~,nx)$-P2jF4+T<9.kWN4Y2ZݢIMQf D^{ :EQe40|c6m-V!Ktp7E{KEhqjEB{v[sr˶~e5n(;A\%ɧQ.9S~m@m>Rlܯ!Je`in5ď4v?zPn)d ^?6gn۱ ܬz1uyxP ǧ{Be/jmb˷y2Q9Vf}Cȑ\ewmZ[lϷ$wY=14"NYrfJLͣ&*]ڷV+3bpdEs0NHzRPCF)Cq8Qx~C; N)<9SzO~zkO1 $Е^xog!ɉ.qx5>R oԖnTz`^! {FNN+#@gF(>ɋQ? hUa3Itv Td< !0\VWЅ8Hfv/Ԯi vqR8jRnlß +:N'8$n /B3[qG"=P>8"-9Z1\sAn9?jaXQ;x9>$z,Nw [*%3V8y6BS~\,.20Bqw7$m*^om/:'u">x:~!\Ǒ1M (z ժaa^P:V$繝v.UpVC[M_Id,Oճ.z0o8pjV-!^E덗60I vլjIh N8|tE?J>P;G-MZժ;~Rt7{yU-jg ^]?2n`ZӖU endstream endobj 167 0 obj << /Length1 1370 /Length2 5960 /Length3 0 /Length 6892 /Filter /FlateDecode >> stream xڍwT6R HK7 tw03 ] !-4()%!ݍ}[us]ZD%m(aH.^n @ ~nItma҇!p d `Ma @$7&ȁ=67 A8Lpo7=ߏ5+**;vA0@ 8V;:pk(H'7 wd؀R AC$w񃝡NuGފ@ ~+C )W buwo|+iӿ E(@ 6P_|ˮKiNPDz\ nex@ܒ rYm~ɌOPq@\|yohMcGކp7_w*h2#ۭ~_mͿϿ xAq&ա-gUT\˟0[z"_s}U?q)'Hќ, b92 KVA,qvAhlvS&hQ[$L\ wV\"VE7g脀. +ݺmDǸhdJGfꮫ5w*Cqd۷ޞ|Jp" be(H2(2'c](1G[iuiexE}gmF_CE)"W`|d}hF/jN~0(.5IҪSPbE,f촗oC!vv5!}Yw_,a!o.oqهW؁G[U,JLقdOhBS+B>1| 3^iAK c݇'EB/=${&Q%:(wDq"F4g]L21~by*WH 4:t8|-0B ja)-9'Vuj:0 @{<=- mE ݖJ6rJeCޖ7FcsC;۫MAU-gi@1 ELCӳВe # '%EIP?I{pC2bo7j9>B ]MbeFtsWc ?mO9uJКoD^):4$Fչݣ 9x)&UTǾi1 טmJrHƑH)z!%_B 2~Xrz]Z^|.̣8*oX!YI:4DF:ɢ85鵣v]E+ %r$s۱s(e3C$vol6 Gkч AI9*4Gv;?+$GvoK-$Y-^ayr+!@Yg)ǡ%,gAt\ZM~™ԴzgvQI0l72ʎ_9 LQ`gYS7޴Fwt~n0#7W&DX%/KRTH#P71v,3V\hj$\ۺd`8 XdM:$w*@^EWk'銳#], jL|1܋3iwcݹ7^݈n/Hn>}0Xy'A `?->P*t.WtPD:xX-dL.Z{|J Dr^x@ݻ@Pg ]h9sēSIa/ Id?A9[IP >=~fMk0#(3uVHw BGfo`3ZHڼ)͝۝R*c9kG{?LFOokw-qaKP_з fVd=џoK#3df½̭ eԜC ۂ.pjRUpY˻LXkP~+h;+ӱð<wE&\ǫ8{X͍pNX]ꛃW .s Ke6@FqO 5YH aQCs;N)v x8aN˕SdCЭuop,a2jL@GR+=_v7e2t=3h18P .Q̛dݲ:#cAN([ߦVV=>EN]ZyZL.dk*ƭٗ d:ep9xBr;֋p3V? O&-& |ga0$_/cY##Loz#< a~ɠ?IUD|GֱrwE "Y[7@f|,Lz2͜ߪP dΞ^hBOhggs$t8@6\AubTWj<,Ue_޴ͻ#p_ɂjͥ־3N*C&F:9Տދ:D-XW`/q.R.+DWzJR̾i}.zv:~P/F !-rMN *,P~ ߞ jV_ Yçb4%7h|}Z^O/=+ʊ٫O9XӕnegM^Э2KYTruÛ`T;e U"o6o)cSh4&l&"7%"a wã:mL*yloIkew͚XU@fù))o,].` gmc;uM) _0v! KҜ%G Z\ݯ7GJL|pu+!y]>KR,IyCUrUMӐm3[˲cV-CRJ V>Ԋ Dy>mtU >CH:\wX}s-#5{(^c+)RE;}two$P$$Zڶ膔E0Zq? 2⦓L8uRI1mg21oL)˴R|îrC+`2?,KDIlK-9.hq,ܩ}fjs˨{sS<*{۟:#AZ؏DrZ+nt$% 0Pe+4M+?qbdJѦhi#IXԹ> &CP8vI!Cu3\CVݷ.У&%B]ϓ'>‚^ &sFt':z\͵srKO̺o(J|m=I!Jt.e6 n"V'Gq*OR{8O`̚AYrVD0EW1lL'KVT,IJDlεQNx3etr 8z ;I9kyW++mC\+iy63b6 = ]졯{xlPǽ l+Kz|,G^c ԟ2.j8$hF$\8! d)/de[ o r! mp Ű\2PfŸ4,*8F|Y_WmdL|;+fVll]Wcb$*F/jdZ%̄j,*eHFoTl֙.6ƃ<@;zB~tPV A>/zMY@i.[>wW/ҳ+QȾ: 3𨟿$r bj`Dz0Tq_~0=T$r ޳7 }?@Li eb % :{&22JG{j:&_Q:>/` 5uP]̰q>`}ì֊*Hm#PjV;?M2/&~N6fXHJctFCMʻ,n(ZRD^H3_hI(NY3sa^=nq0FphOLZIL&5Rpv]3S+7a/~Mg%S?Q]);"J^(SJȺT0V HH}<ϗ4Mg@Z/:.{,n5ܘU ?4\0Pb{2# G::6 >[dbAN;zv#&]zU>ص> '^ HDJ~F`7 Ҫ!gC?ʏ׺B7ǭFLZ Go`2*NZ[*&O4J_3֢pؖp]cF+ ajƼcuXameđMAl]5v]2I?T6WTa!+kY7lH "|~1-fv֫̀.b9(&#> stream xڍTTT]RBZ?binafDNCB$D@ZE@ iAw{Y뜳yk<FJT  e*F PT!1a?fRS(C"d@ aq6UE"Zp(@XBFXR"2U' h!P ) 僆99cqe %ܠh肰P7\E00BaP?R9c(!!///AFvx΀P  ~ AO&H0va~ۍX/ 00Ex P4W`GA:?{w??A`0 BNG Wzc ' q O r~u+@a(,FQg.! *H77(!ٟ* Gɺ"^? GsJsjLۜX8PZBB`g}P_Nf~($ s>~'E{@+RaaN0qf50o=a? Ho2VQS)+#~"iq)@RR4 ؟6j"_{!qKc-7ɭ@0%?_$φ=_n_>8z`qEdOhuz5 N82  ~au7bÂS0[pQ@p \P|YW FB~LD\BA>@D~8AB޿ D n#MX!4 }Z8'? =h~W__B`ɏH#G-'5J,^˃Wg",zű&rueh+C*R >~gd{+j=ʻ}^;A!HfaԈExC6J{+BۉfC%;EWV .0қ7@g 6F)m?ʂ{oaMKJ04+D3,ZŦ雞T~ 9RYwNv ~~Ч@9G±Y!IL]pFM奦x޽4f_?i2+7 ?1oƫ졦l^R4)8{šNj[Z__^:H}2Evc& Bb"O5|zYз/7QvLJ783GvJKJP`sޛfܿǚ̸95Q2u#`T1_zQJʞB]ՕaVuK}m5c>5ow 3xjɞ(\YeFh\<_\:$G\bg`1#dOLs"j)7Љ]6A38KZcV*ny?GxPfkf^{f9&~-.b21*λ>Yd/im6{dHZx%{E7Dڋ.@`Q@cwEקëz1s=&ذf'2[40HW/;W—'Wjs w_p667( $͢ MDocܲ疪|'h@;\=1o=Hģe,1Rj%/6 xe쾿 E:*F|e0b8O%̈́KCW !PbTмKv@vJ9TYu^|^]-y2=88|Mpr"%[`B`'ôsw;t)465c NX^'/ruב4Ogd<||^;8[//Ikj5KroMT(L\K6N sƜrҪ8@iEl^#3m9NY1$>>=N$|p]'~}ﰻ[NБ9nߟC{\ozSeEѝ˗ YUr:M4*"2Uﶖ0pHשּjXBR b&t(;5ٗdV-\ԢFd_Śl%-A7 >|~ u.GHťZ&ާ51y;tyidz'$U[%y`1i>P@o'Ae>aXBіA2gHba"\ñC<9&sѮ%{ӼEvrE|Ue{$JP~vsZڂT:o1$?l^ ۥX^&3//<[\pc@<3vm%p}YDtnP =\5~(`l||L̉ kJOyP\Ĥ'O̳1py11nbؘU h=XIx)J|ܘ@|Y'w >qM`~ۚA;eū}-^%%@с`Iߡ.,fd=dbyO2uj?7oRrPy߯yR`(00K ;)C>&/3 qhaQ磠%n3~]ZpkA{ Zow^8jv`GDdHU} J(#B&UW^!)b΍?|=5E;cFNqI44\یV(+C9 .XEZdƄO. *T 8sGFFkC <%hn٫ɧ5?4as5aczBZWWS!Y.nr9jQY(AohddMa|rnA"*3!nV{Jx! Ȃr\]BWFYpβV\_!5\t,;-bUDz.ۂmϮwCr==5ZzQ Nz@z*,Uױ)Łȓ콓TikL)&2+zfbBDËsjE+Sp ̦u?w5Q_PxcPڼ:lckz&r@lFKn[t#e3 }Q&;I;oT'Jx22 8t]Wn X =&:Udu&74KmkUoWu=$L&HYH =h.nnɸęg?w\?_Y|_>P|IS{\eLI=QXtFSϱ{IDKAW9H(5a*[B|/| 9r̨O I\5]bQG+$J':rXIQEG ߞjҍUn`yAr㽓硙OJkFQ]4Z|4Qdމۈy WчaSgGJ[@]g+b [94̚(_ʔxX> t{x5Bc6g$W@BQZu1j;U"w^O=[nKy^_?9}.Ih"!i#U⵳$֐0#o@:ÌQ.ţ"rMCⵧc`̮J <_8O9orK^ D =7|݈cs8W^ytf214y8sǮr)YUf9폹Y"_2hYχ1R(~іmGV߉%ϥXnMTmWD.wBr+y %xCԨBܾX'OMI&UBWNod1ܢ7\o'Hkmc!vR`:j2'⤰31!HֳNaqȺA[Dd<46'Xߕy8֬c=bb+l+%AFǛ'&SnQv ^ dseg#(V3  XZ{IuP9RNBh"^-0I3 p#U\[a\trWF/i JQn|wޘ|Qm"bMW`rM o:I>LnT*-lFdQ>Fe܁Y¤Ů ߕh_rU|4ETɌ>|l;oBmTLEnnRhG&W\0''jݴS'BILCL}&'%\;wT//XTr%C-8|HJa;([=!qsoSQl$ ]ոopr3DM>lʟb0[看`)8&O3V.z9( \kjjbӋ9+ e8{N+S)ۻ5;-F(v<{3$XhM7"wC]?S Jtdi/ֿ`e.$/%zL5E0Mz8GBK^>y:f$+ 9 L!grd4GBauI!vh0Bt- i)F7IurಡK% u㵉0SN)̴7{7ȭb:'Pf9$kfvDx#V;\8"fa~f2*o:B7Eo{-+Dj>40A+d2V(u zt 99k/2rj{r鱀fvօ9AD#̳t)쉋83Kc>/,?=: ~GLADM$y&woh7@ Kpa~;0~1G×`܁يtJ/IfnX+b/{ endstream endobj 171 0 obj << /Length1 1510 /Length2 8932 /Length3 0 /Length 9941 /Filter /FlateDecode >> stream xڍT6Nt2t3tt 1)%! ! ]-t7ҝ[oγgfz-]nY+X Ep5Tx<8z_vf !!l QA^lAXk/C/?H 0C"f{@.. O~@Bo{3!B=a.8/VXTmD@пzV| Pt|P7(>b=ja? ęYU7_TҸs|{qeH嶩(/qy,9#>yB_t_ooDko)F>[ӌnm3B,y WwPkk{a.!o~"3N|c2}[Yy>&kOg^T~x>+(>rrcӠҷړ*`[wSq6z^B;KJI$qgFW| RQ3Ճ'fs i{OZbDDCZ!eFaM;-#*Tp "2<Td%^Y_〻H{T}]VWY)nÁH3)J:U*2f/iUƛ%xx4<\'g>N4 m\xcr\-FuSrq`|Xr:6w89Ԓ+D4;zit3ݶnL 'jêoqr}0ՎEZG:*)x5h`ܗ/$Ӷ]4$0y,ƿQ7=R~2W[su]. Շj+j֭_ʂT/ؘ'ܨ9 £vfmũyz@tF}cB(~^*mzv׏WcLۖ}*VE>bnrj]jln[Fh{0XJ[Ӵ-`7{PcMO<xxfTU UD` 2uMh߇'A|/|Fe (OҙCr9W\3%Y]wYct+cVLׁg}ÙÆlAB,cKVyֆ͈K~SLt|Q]şjm$nۮeט7 b{%35IF eJdIFࡩ#?ɘs+3akyw:Uvb2Q-ʈaލ̪x`S]qqG84[s1my LJQF|dC==_eD#)z{2Жu?@?E{TH,ZZ7Ѕ 9(WkW7Ъ˻3w&x"~CQ 7 B⏏f֞q^42#7?{J`|0t0; V]b#cywK"?O/5vaNn)Mڔzg\+x R(\!I-če~NA~JR_*띎>'MPz\_HS[gּ8S69%<+ M4t^9q[f&`E,7qm:8<3lJ6P@&V V%0_Cx͛#\V&Aox|Tɏ2跲?.Lh3ڝ1OK5$Vp[VMWE;-1ژ6˽[J;. SU:]n@Q~܄ A-GŒnp]2 ѯ K:.MX̼j+}cH:~](v7EhQH@w@ T[f:4Gg!],̩+=% ֵr>@"ig<3x*C7׿0fknl>^pq8kb7lm/#nOSۗhЮ(%1ޙ#=ɪHڡb2(%7b$?BD䀶_cCg{y>:/QnՑ q(zMHemz ؄=EDveED`;|yg~}OMZ:29!kie1.f4"SUXQ *&YiAD_6j si<鋂o^VXZ݇}Fah~V~{A-xfOx?Hޔ?A/om !&% wN6GO/fEsޝOP}ثyp|x P}jYQ?e/Z@-ӚW] HTUM͈BVq*uc6|ِ9~2zţ1$K72+ꂽmP(RgV?ndy]v V>o& 2S퀟wL&JJ+Ч#\a5_ՅwIfNH&#qS*]?e6" ZuH)V~v9pg FŸ\FߨB.k:Bß)6s0d;ϭsAisQ}\NvjإJnD8.6܆uRb ) x1u FVWԻZL5E8̆Ij0PvB.KyEwt#hz!ck:N2P.ONZ)oBb=iAjF ~+hTW;[ UMIU`w|޹P .%豧٭&~:p=cx ~8 @SdO'r )Ur-Qľ#>!o=^mW%eHkѰ;0lPerEj>#ή՟]cz@j%W{^xUCjQU BOHjFx^h=zS{t}C_ I[M*ʎtEESI?8ՙ-JV\2Y\}KE\+ʥuZAm Ҟx7A#b dB~o6~T%MDZS;j65޾4U~XwT;] I¨ٖU *=jrYKPa~} td7=V~]q) *Ҹ!0ϟUmF$O+OZY& E_y1}PD 1W)fj[\ji Jy4g*{c1 -GGyl(c0R_O6c5JQGRj/rj|=M/?ŷ_xԚ䟏 -AΊ"tzfNlÔ=IhcblF=F:#>ٶCxa&BA/\i>"&O峸(& 84_L'$/qH̿ Ǖn<:fWTT#\ۧBQ#[c|SO8{}r2sNyV(/ֲV(<{?&O?`qE;XA=kaWO羚mQZRf6!Ӛ#/tt.ѥ @EK C*w7,*bdfT8/ٗwTIPh*͡tfFPzMi:O$2j=@&4ۆǏ%RV }BÖ&Q\(s"l-Lz1a҆\Z`rVT}+eZGw )JM: u,f I!Q)ȳdvxߝߣE nP]K)f[Xb6oճ&CY?{怖9#ۓkǼozHZd^}G7iHT35JNKōRwL?J h/bU]d}hʛSR,;3ECkU_ƙe;6EH7¼"Ͻ/̈́^OwU4ݍ\,EmZԚ:+D g=( GyetIr"uqʜkq], ȜKobK`[bx$ nիx1,ȩ'lF=B^>xYP[rFv\CujҒ9،..E-0 Bk<+Pz:pQg-Y]V@pye<@6 ;W(ayنU8F;݇7v܀5{pНA> %%5sQS-@*mҹ+!w,gL%M?g>\"5]g:igKVa~vy&6LRi Mnf\& >)n}D)ł=_o:3hz?OU4ŲIc݆|WM}FX%t5 .bu{&aK|mߩO|Δ۱>eLxh5g#`a9[PbbNεr¹{+4HxδƩZg}K>IJ̸q#q0_MU!8 q{[|ňM.fZL>bFTg/W$ժJ_mC v&<Ԙ- x]-зV20/[Ef@UyJ#j{Zhoj8 Df.V+:ZB5cA%N}޹g!rMm>|m~(!Qxw$xs N8ޙ.Մz|( DӐٺo4ڃb tM,x3CK h&V&j`Hb Uv5t7W41ܱ V"Н+~vhGk =6*oU:7Fk a>"2g:1U$d]lⵒ_Ơ Hig| qb(Ig(ݔ .+諞A5 4q-h63+q#xX2QkʹzflLX#oWA¤7 g;x,VKLmd(iu'hƹ<]6.HFrxX;q.qYGn>poorϔmzwi SrC#~2/dWhĉwBe,F@AqSL=-GΑLZ!}T.alVB7a $iB)%i&H3MLwe] , n}To@ =f ϗp\˷ [ua[k$o (z;ɰ_xlx2 oXSMKڝV՟D{5 mJU`?1+u&zk}\B4Nfi4z/JxX&0. 6RY&C~U >0XɎ{}W~E H˙;쒄e?@7¢01zůZ]j3 LM&;x9v_^W*Taw״95Dzs߽"ݨI67`ܙBKzLv/f%=oS5{+Kݽx]#XŒ颎ǛDԞlfИf륽f]j)j_ Fa_;~%($2Qb,R-,1P_<C8=/c 0\:ND~ wtջcdvNꉰSMl`\bb?AR ̢kKZfҴ{;(1]?oŤd8PF^bMKSIEz ޲/:a!/Jxj94ZT SݛWB՘EM7Sޙ]3c:(5G|ќLUCPa+z v;8r̾Ȯ?oST endstream endobj 173 0 obj << /Length1 1569 /Length2 8473 /Length3 0 /Length 9508 /Filter /FlateDecode >> stream xڍTk6LtC4CtI4 1 !* "ݭtK# xy_ֳ<ϵ{QjCMA2P+' @RIS NG v-G{ rYH:LdR&NOJP@ pqpmuHJl(Cڻ;- `4cp 9L %'+SF3[ rrVNN쮮l&v06( dP@. s&vZcChZa*4N& l\! GSv=? X pylbf7! -"͉`1mhb >mML ( #0y`f`{' lGa, 1ف N0IAfOswgpm PW 1݆= I 73+ 4A(9z,y-@O/tO  :''l0Y!D,Ovs<яϗ̡[8bvu%)W `prrpx8GWC,?}%ƿ ߱O!;gQDߊdmm3iћ؁mxb(Avڠ?WW dv_6C, d)dn sU՟S{l*}X>oHnq>ѐ/`حyPv@ΧPO`v53gGǧK? oǍgfBAuAW5/]Y7GN#Ѵ7I\$ϸ#;"WJmt8l xE 7"[x8sm)vtsC->u==Dp9++L a$:??7&BPxf[DT<-DrA.2xj˽{;ݼcInqA! lo}[\}6_Em$\.H3U؟ sN\1'M)QeXÕ+Xe6vYY >)e]+.6T`׉Q.㳔=F<_R?5xBeN;@y;&PImG Gn^DִeĖv(YوID͗ԘJ!O߱]zנ)v9ih._!vOB. %V4HBW#HxjRBA_iBeًԇԍ*_ōR^#hO+OLm*hB7G$-Gz{pIy&5C;؉Bgy~ܮBIƒL8/|7؃%hMǪrtoA!M@ |K#9 n"j*C(϶64Ea0+j BJkJyy󗥇n+%$ - Un 1ni)(J7GxXoaux+|O@=eۻ`넣* `)) %$*<`+\[qNu/_0!8^ ҹzEllI>堶Q d,.@O1HzQgϜ%!wӳVX.Qc#;1n/oGku2:gKc?GCL1߯K_W)aHKm 9xy/%A B9z]M[vuS/G|: 3]P[T*9??ϨE||0`hkW@=bX|s$)9D)(>?7;0rU50M{SBx_ XnmW 65tFr%Jց!?VHϥԬu'9{D  e| ̗BJ[ML4kd1{!>M ]=nio -[UPT$(Գ#q 3⒗qpKQ9,NUQ ꆹC^㳕Y9g0/WI8'`|xblMsJ$}ڌ #/8!zG+uuGj;#},pC'2Nayԧ 15*IB.Lv[S|LXȆr:/!z@H4R _shAHbS@cI5Mlcry?ͧS as:Vm?3c=LhRZN$:*a6?AhݨHw0|Q.aϳ~5W.~w]3KE(>CrgmF5`m=쇿nIKy@椋mVY @ʃېZ <`T5R4v)͛eIҒg&H"cM4st)GWsC t=/z+9,V]{lQUcAg1gB'^`yޢ8X$ QoT(^9FT6wH}z l%NF !12oŀ w=+-txWp H{i;r1xO G:v:k` U?vۗ2}3ۄ_{uQ(PN! / iήʙa4БVsWͶ8.JCJ;SZT~u-[̹8 (JŒdۋ!IGZw##X}m:=ː a;ʈ DVV0@2+;z֜w/{M 5D\9wzK<6597g/BU0$dž~=X{ns: #GcV_HևxkѢ̕t'-PL MC =xcyN~~ Щ09&pL~\3t,|'!_} /}(-} "U!KL;y#%T ӽ)6#yHk VgKYe!V<)!d0#l;ON ʹfƱ+7Su)3;WTph 7 GF/\0)@ni~8-"T;m MJĖ_z\ьaxRv mdN11@t^(ږGRRivD9M^nԒ(Mrԛfe)AV.DX_^e U 0qȇPGezV8j3k~lAw8s:wC[9;J5Jfr#8z̈́޲9R+ @ 7!w gc"v),hrinv;1c>".;;n TI/W0g"LdC!yw֖U0Z[.G,OpYnȯ ! Kz˅6b/xjIQ$۔we3Ή~T&bg8:";u`[ˋ)*!RǮվJ,p{o̰o=mLԎ{%?݌;iVDH<-g`Uv=,@q[[~',qwtj߼}_X=hLi@T7nb{I&Nuv4:=F\I5q&sDWB\sf_uD3p`Yo6ჟ%ZuH_-Dϥ&;~d#?|0eʉԒ+^K^}Vuz 7ʫ2moF @O q &5z‚y,elh5NEJ4eHֶc^WJjҐ{r-%Fq%1^= j^ J@pݬ`%h'!kUsnJ,Ě\̔3-^gLm׏EwgF]Ond7Sn2O,6, 9?{wmC|MO92#QŒ"dk\Ԍ8o g .G/X߆3[T79_}܈Q' W<>UJJF  5[PE(-H@~ ~NkEܼ># JRHXKHtF" h]R&*5Z3+E//4s*3(4!R֌ <<2OQaϐ<2 +T(RHOA=u1U͔ix'JИO:'/~:ȒϫpSɅx!3Y^{͙)x^3ZrrY|:^{l'}^ ʢ޲pjRU;`yьUR)+Ek{5EKbeM<!)l7iM)%,d`->@V\#UyMcP뼑'.},VG nYNY7fò$m擸*βpIZ}zO"͝ЕY9K{KK@zR~NB[l6Eř 5OYP+jU:g#1>g3*œi-t]ב-'u XWY/@-Hl"/oc`M+K4&7es@Z;7RCSכ1=G̽*K,"_,;_6ȏr6(Sɤ7h_HRc6U|F 糋%W A #f*dfcǢoyv$[BX~!qfV6S>9!7BI"WhyqCZ;mAcGS>4GX_wrH!jw ]%oMY Ќ}_ȪX1d)tnl>\8vH#gP@xKsr]j5mq?"Ŭ[L)ޏ=hШސO_(D`CԪ(t&+&8=yGbmRX߆n;9!3|<6^@d38GlCLW}l6z[wT!S ~D?'>G=$mEh ]5BQ3n&` j >ҏr Ny:x,Ӎ N( L2ɤ@m~QհɢjWX_ &h6^p8WmG2fQ 1:CK]T(' .@C/x21<$-Wa~nR$ 2 ⊑QX."{U%RN+ -`p]cۧKh<_È>ytH(Qz}lqm.HJɗ>W㗗[v/B{bDŽ+љwc½I ]CrmGoC-H7<)x>rTl j#{aQjҞ^DE@!B I/ԫU~;Uevhu5c?u<75]Iu3W6>K OX 0 ^t.U|cŘ^?-3q(nxSZjlzb|4n1/!4aG=rHo4*>b(!e6E&ZTx}`mhK7v\P%z+6.'r2-*Y'T)"ꈚ7Wڛ5k[/NW*0*Tz@z5MPO#Wdf'2d$Jq03C;66pSh;ʝD 4^N!Rg*<~^7y}/Ыd. CƮ֏\~b.w, \]S]: Q_nDOئtŹyMl"^zpNQL {͈O߈R)pk*֑E5F`MVw̗NYLl*j|ćf&(B5f`}@4IZϲ(sdp/G=b˲}F5mRŭ~> Lb<$WAz|RRV)Ar}Ʀӧc=w 6&|yw bn[㈶4>or Wy̒vF.K`sz9:t< *X:lv#k]6-38hEO ׉Ț,AijQG){@r{d VxA‘hs L;tr 祇XҝGM πTgPYls8`rĬן**3gP\D;_9N9y4`GSe}HA5c<]y%J r9/.`9#K\>Ő:Sinvy~}WBE? h]hc=q~ExoqKh6 niw`iǥ('z9(ggl1T2\_i b٥>R5:ó6zeRM"3hvrKU&o=w QquE[1:<TBs?C.o v nxAV!KKˊ%&75?gk?F KDluf3™W_ͺ~6J;se1Rcuw7ζroy/h~uX!SW(✎A' SCenL^c}m<|#v0@TY52r'W׫ u">:F Snՠ4y&\iC+ijFEB%>=`u".]$?˶$F鸊ckIʊfy?0Ԗ ĝxDx01eqjXyّ(хt)3eʳ;<qO?9ؒmkߨUJZ8dGEeЯ%\X%sQ]lL꒬Rm.$,D4͚e˚JӇImω=v,"*@|@/< s=c(gtKId1_]EYm8q/L=D5Wv +lm+$s<21!WZN]ueQFzŢcBtО/rYY+Z^c46Tp2{+} )grPEPJ^\?~x߿um I뜘$G5LUu_&,:s`GO3x `z&u endstream endobj 175 0 obj << /Length1 2576 /Length2 18173 /Length3 0 /Length 19678 /Filter /FlateDecode >> stream xڌP  9,469&k~])RRET !9(*(8E_/&62zފZOE6ƞBw$jgB-R$Ĕ!SpOHS}a[IURt[fEǢGr4VVI)X$OR@rա*J5]Z`b\:*A 3X HaZ =r14Nj"3~ ]=Bjʄ) h˔x d)D LtuEyZn}0e f%$Avu],H koq,z[.[ _~Ņ mF ʮ6S~@o64p&LBnT+m0V%f;7ADPt꭛Bw"DKXI-k|uەr3s3($ YC,`jؽ) 6QZpGG~@#M/r "C)40d':k),[Ѧ-m =@!rg㽼խf/([ºrW&F 0'^-hȃm@ 8*Okdc3wr[zTo5C(h u' (ڜ2ީ? B^id/< q2D*n[?V#7aK^zr8shFa}0v=^G>@P;HνR3Bdٞ4 ?zۇKV#͎wqf-A-VT9}D #9c.QBՍ.}_U4 t,e^n432w=*We8$].,/ǚ{*j׭*:ƾ2qu'+]{vgW.i XVEu=k\ $h@tc.Rv z~ac 'zg5ky²250\ư&&O,.s|>6<骅)GOeHW[-y)\xU]F(Jwz]Df@ w@|Y[C,El#)sDVQj&/X#Dz.tI3'Lx:xv>zo"\mYPBMF~jf4b#kkEgpN8V >qO܄2<jdא\6[F£JصTOX#'\5(j)!`+NK>G@ o^ ȿ*v2uC"\Rqc2$c72Ԝ;C3skaZ#e'Ŭ|U]c2mr= +ݡuVqo“FzrKyph>"i +O6Z@EһF)x~8ߛ-̱9N%o+g<pVІ!k.DYL ;(X ֱ&nL”ۀZn@O)U҃1C l@Bӵcn j=%4r=|D$Chhņ/LʇFPW`8;zTe8sPaXm :wJh:R*.if&$`):6J#rmlۊKu\huإm[4\g:HƩ,<xm7}u8I1\Ce}kKI)w=dHhF߱Dɻ6>뤧qC7i sSJKz+Z!xD5Wd ,!O3vV~AD5/cRKBjU0kKjPKS 03n_$7NU|xٱS,}z1Y} mQZ K]_'͠`SYkaT]uK;یa͘3䡸.ͷE<~`hr|Յ#(ƢDĝ^NUa {cĽLbS5JީLDN1>`|Ԑ mJ>SR&Q4ުۉˍA\? qU؛j1}Nͨ?BH/%P%dz"{^^qq^4^_z_ͮu.nFި8#~ϩ 'ac:[XΐOj_I:=ni#VV!{ح.QY# n`gb >e [+@ >l{FVXC%z'J~h_Hf1fڴIf~˹zxlf*Y$»-CʬؒB7EOCEIsJ;FD{'fE-_z ppXYvA0yh|BmNIto: =Hp>Kmq;| krڏlK8jzv`@kM$`U뭽<X.Ɖ^'9"Ϡg]7y (|pzOɠ-#oǾ5~VO ,u8TCpOOp:i:'1>66YҾ4|9$}wk4]x3&XvDz*P<!S~UYͪGj}YӬrl_ϖ[QH!,BC#6HQ?U|V3h/0Y:Ȗ AWangp|2Ic>f3X5e"bSЬ%ϘNk 7H ʠ 7VO!.`S8rCMa7䞲V8yKZ4߿:ܔ0zMuN]$笀q A9Ԧ &ftq:g'sV!^{) S&M Svό~4vl{#rф[:OP?^4jz)hw 5͞0v ط0s PEo)e;ТU$9t50vJkȽ' )Gm3<$+Rlw&BIMy=ʍQ"%eqiyRIg!'t,]"!P&y&L +93bf24JY1)HhRw9,eՆ?M#nrQ4 %io~5=So!Wb qsW\}LK@(&ȇl`ipղn@fYŬ7pg&ɹwqaLsNo9.}&nXKUoAFMaMk{w[|Tnir5e2q^&?u*+|Sr`'yRlŒn|bvXZ&3Y#G?ACe { ze8'̉G㾶܉-HE37โ[1fF m{=O?Ѹ,MMo+g_tER񥾘eKHhg]oAguoߴagwtޖG((i&s4`$ʼ] 4&3q#%Lv}M@ E>:6wf]Tdi B7EK }l0&[/y"54ٓ јugzd(%Ҕ6\=ze7$WnbNe5Z nG++8;$A~5IQ4z>PK0Z_| $(/`{rl|_i;x2$B"yȏx'{KP &wsn/ETjx>WS4 h&!]/7SJ'dQ_~y쎲5jnFjXA yqpͧ"Vgn^ ZY]64Hҙ_yv">PzC0tVQl^pĮMz# zKqL唪2](Q#<)Xֱ^V놥 9wn׍* ,X%~B8Y+gېeJdu<`%[4kª(^ r1ay:\1XFX.23R외tS*W%o }C\ę?>_ACsQfB|kAVԈ`l'D/B.5 `8w%ϊJU,^Xt]\00>֒Z~B*t_bu\ng ӜCL|Lc3}w1yե1Ms kaѐrAB0ҏ-M6BZH6l"eb)?3ÜM+1!7]6Ȓ9Y'?PaHk0KH=u!iՁ,NV 6W"e"m# Dt[!My=wo1Ix@ȁ М"\Wjęy4w~ 5_P2W L>iC6=:&z,Ep<,s8 wPdN[ހҚ2Ц_fGC^(R@,Q,԰>x@t\E (;m\;=B' 6F=O{F䎺3س΃+Ε~)wƇY5o2s[/COWj^VQ&EK' q4-mx0x m@Pi{ҧ38g#U7T$? , ,.LR-t׵,VSIk -u4~f9ӝ*X(|i)$_\ }RlivѮm3AO읢K&m+{pǟ #yH5ePhy6%]x)eJ>Qq9Ly*ʪkbge^xN:E%Px'h4a*T/l VB*zU4`ŵd{>q`f{H!} ݴ73߈¼Cj-'ClhcrI/6.0bseegbyVd+]1DX/ \zۇ%[J+% *,AB_̊U-Sc4}1FzS)V'W@=)UzH!?^$\47l]. ?N觋8뿼ja2DPDR9 >K3Qos7HiM#{]qC;#?.+^)*N, ZHI T+xR`J+~ 4RI+|a=5Puv9t~ NeA|Gc*Pfd{o% jTi=[WVRSو}Mk%/3D|fZq}-(j|^;%2tC.̀Ʀ6['L\娳iKz}u zʯȅL%b(XTQObh|V}u,@rgKIh^8+Z}hbŸ~fe̳;ryU*Mrx^=v"UfڣhҢ)̋1 I.~ޠ 4n}|67^-0SibE3D[Gjf]?:]X%\Ż?Y>c& xw5Q = y RWӊa'7#Vj+DA%i$[ဘLb5 T#\ve%2J˳qņ?4Sn\~2}צQpR%.=?)34v#8 =Xda9v0V: wiqd4v_[1cjP2M?5S!WARdR;!: Vb{*w|)#1Hcr"=A-h幝J*w.b4}J$Ub̑>ܵA%]l|XMty@`"NA/XK_U^7"P7я5TZhk CiS4c*أ4vE7gk?XBծ l04 |-R7erWD<Gͳjcy~2>;( rOyM<R<@ר;4Ҿ%Me Lԓ2i7SQYG^V4SlVI O6bҠJ[&8Ds = KYPI?'Щ)gu X/% Bj2LJIR&((}M!S=IZ6;EMr]+Y'W}o&Ӳ,tU{WU]Ջ/j&oЅR#:>L>*s{紌=qk^IBzvPb1C+Y~Q$"\ڽ2=No_NjxYKAuުp졷wJ-`6=4P]I Y0?d9:kٔ\S^ڳ%.{&elJo`P/mc]W|G~⃻N׼w 6)˞[_{g&OW7x(S;aC?ȻuL* 1&ٲn&^qԠ>< &CAí X~WǮ2'Qk\ ;n`$(q`|1|~._lċ*Ϳ?brqY39ڴȖRjݖw'8XUZj(PKZ07N}7'Tv F_hl%\?it^ȁCc s4IݪxGەz)ޭ8)!ZO.Z۔~K3G6d OG1U?x (ɋ#"\*U]Ԥ5"za?"zpM#8WaOhU|օPx#Br 2~uXj_X×*EK` }nk.('>jGG(~8?hqܜ/ 42kv^w6:_}زL*A4=+:m7hd/_-ע fJ7:>=^g >W=8 E?t8 /5Hvܿu7䴺' pnLi.S兛4*]G?"涤MeFXI{%(O=%˹riQ6eAм9ZH9X-cv*r7ݍcg cTeR//.E .Iba@ڟ]2xά$UrWG+kRWl7I#=>J2'L:d2@AdUIсNd<}w%v(7:b)&Ge)3""p5s *' (S"(`-֦Jri:iA(Eth#O,8d^a隁*4^G AE/\TDrOIƪ[^Ƣ I@MA Ϯ=뺷/!J[F>|z؄bmr!foܳAz_2^~n$Yc!F@./ -^h/XvԱjQRkFGʚ)g?'y2M hsJG~U$9l󬵙C,j \K;oHQE%D:5?ԼRSZKjD;J[v>$N>Ӫ!9>yb^$G- Ǿ-OWt\ԐQZu'6xJ\ȶI?h%>@$׽>de|C9yhdIYayo(X_ Ӥqiօ"Z!1F7-VH UCq1>Q=7&dEeǃN=͍I%9r ",~=ںW#I*dC@ alQ5{ð 0佽 o站Ɣ+x ;I`TΆ :_aPW,5;Szӣ0rkrQZ]t\jZ%}F8<= 1X{TAܖiKNeVƻﶋB&?yŔ.jP!˘{I9+wɊ7"pGGZ~=x;Zu š ȹH`K8Ѫ!4fDrՒGDžʈ`̀EPu8 S>7e~i:GTd6k9ΙfZё 1N2 6}Yy dRwYvoQ "m &PՔ^YGN$ gy^?sKk?<%u vbil"TgG0pb6naO7yV5V)T93jS{#T"4:(tCm$yg;=YJ1 ZCKgDXƋBRa##l>@$ ɤPdsϧXF#nCO 0GC >G4^8q`}D! HBIJc4|c3'ތtVJ^[~]$RTZZ)\J`DpzO%T9G GXaj=ugd (٩6އσ"Ii1B{mu#"df }=Q')#<%4z5)LC N0BN!ey+?6ɤ^z&ڧt;#UΜ'=[|g~`h -J{Pr3=)Vs+)BY0>- _Ȉ;rL_g DψSwz!L dZ,;dy̅j NJm_.(&[р-mVo^P$]E0ׁ iKbD*:.s-/*Zᢗgyt.* z!g%Z䣏 ^B(cj#h|sl&ނgR Ge`Y.V Y5:h:XH\r, Aa=[W]uÏzj^b:Ci|@wd$/?iy ,ءȖ+i H2U|+7p`|-uêА{jEHT)ߌ̷X:1sVPHޯ,pZJ5hFA>ߍ> T?՟I \|1U,s~EVaV4〦RU+C#J0xW\{cOϲ],J'4ʹo6rŀ$?sɽͪ_ ݙ0 tXQ#@kq|3WzSoi Iae+Js{q؇JЕ`4|ܱE۳U3e As؜/ _H{%k æ,F(0AI{.[: ӑvL2h>R{xp"*WH("T< а&h뇜]OI.|ط93]$'<1A>L/zw}c ]ikz]ڊ8>˪8"9*e:I `qԨNHj^&MNX0 3vv?1'F={uzAn) 㬄X!#b4S6oJh=Dx-WӇ9ҲHPl˱ =yŗe_7&`7&9fwg5U`~+=q`bg+"ftGi9+N|N2oA&pCD_*zIM5BsUD9Ŷ\~8k!!1*f]pn#]O:V9m̶X*+^Mmk Iesr{=`HvR9{~QD5͸{akB:ä.M:*u%t vY[=JV#_xyEdP4UEB,wI`1٨?gi6ǭr('r{Abc}KNɦ ^gM|VNyWl?'PQ[D(Q:﫟DY%idG1F| &jD)Q-05>%ME7 VxД>~ЉP!;:.ko!VN>GHrj/X+e#=8țNwc.*Huϙ+H͕mR*  iydD؅|DŽ0^k$j_WszlCuXZFMI˹pX Sx1Q )VpP7 9I N)6-A>:e?={KQTV ;ެߺvzg9txQмj Cg6L73'=\ A!!;WpݻMdr+ە<g Y֓J4x*[,Ml &tձ<憃cwC`cQ3(tr AJN;VFh'M-afht ӕ˓~cq=BAqd{ς[w3B~]mL \% ЊJ Q i\9ϒy+ՍnjUgFl)꛷g=m&;4ubĎQX|w(wāxK[uIӷ>:}}G"qH,/WpHYӔ k3cx~̶Ui{1ЎQ~4ڤ^eٿ&Gs~l#v=}ZtS&!7/ĵ=.B( 4Pb*͈LsK1fG͹ȗsV$j~;B C8;҃ qRiLjI<XEҳB  Qdz)GS`znn"G(>z-$Nj(1{hFiʷ{ ]&Jq&0궪 TR ;Q _4GH wl2~Q^Q1vqJ)?c:Uw0{HRLj0ߩo3# xKs'i_ w~bfʉ!i>OdpD<9LbϭT|¤]޿g8ӏ5RmmJ-.sgA!aK\It\aD1v=qNSD_1lƺ>)2 >+}qmPRhlUN,C#39ݷЙ=9Ehil+|w O8 fNVĥ j")"oA5 ?)?"nZ53b,zGX#r7p1## , 3>_x8A`wl1av3[^ ;KGwSczsM@3F' x{I1{쬅 ܹ*6t,놷v+C7P:H;t$ԏvS"e6u)[[׸SNNg9ُ|f B044d|PJ)/=' =Vߦ3tB,4}d$. 粆(e>ܘwUL k: 1 ;҅XhJ:8=!7-oQ^e~`^Rvjklgz/}Y,^Y;_橲6%fѣ5&Y5d azGTlB}jͮXԕpw]qx#($ܩ(EeF+H)~;TqZZ9ZķjwP]j2Z:GIP endstream endobj 177 0 obj << /Length1 1856 /Length2 9906 /Length3 0 /Length 11073 /Filter /FlateDecode >> stream xڍT6L4H]Jww C7"Hw# R" t7"7z={[5̳~  yx% Z~~!^~~AC0C! PpMGiA!u/W@@TR@L /@(L;xPE;9+ݞ !!;  rCht@ `v%|||xnP#n y` /m/f8,Cg_v#W=8`5M;W_܀gٿ !P7w  q8]AeM^/8 zB@o h9,"Mv{z]QU1e% {O #ͺ@>#;RS;acs"Bk; (pDA8@oG@@N`Ο3/|`О?߬rB\_>uu3%}㓗xDw@D\e i|Cm84N5k r\tnn82yٷTJٴu#*PeIO$=`"!/jnR3՝oa&CG!B+'2g"X\BoT>UU''LޚIѫLV xA|RƁK aq%ciGYRTo&17.;-$S^2g?sg`+^2zdhg4XpS{usL$A!{3ո2w5,{'eV ܣ:| d-vB~c$<%SlB3XZپ䊕=T?bbYpd*wSȉ&,שּׁO7 Ue ?Γ1q/Zsr*` I/GY7xgKvQؒӠ2YW z](^{b)NDk jxo_'m"v,5s9䎠~7/- 志wjX -W{(43`}:J-ZC./^oD[^gT>v"^^}rPWm??8?3}QvcX@;х}?%H+ . ڣ68Oԩs,-v3pǽZFgLYo|2Eh?8(ZNE2W$I^A}X֗.BX5X0^]B>|%[8gTqPws 97'70S2,Hpk|ŢOqR mzhC5ɟH;l5Ҡm \XmpB;cHEiu]$lK:| .̲r!;'+b{} '6ʄ9%@uoSzj<=WT };m˾T 1$0Qs6諌Fg /-%>L?ʧ ĥNZ&=fOp'7i'P%~ -CuVZ< HbSimYZxj-lny6BT|Qg'^K_tc'oxzOڿ +ӯg\XOyfbf+է׈ ۭ 9-%CKLK)n}CT)Z\;I͞ϯH4Cοf SD2 g[ Hf~W, ,auu1!Nq@)&OڳE{+ ǐS%Pq*pў_qԷVm.$Cʋ^;HU*RROb6a玩 Wb3t<$UyLB/oA_UZWNWFs(IH0V,~ 00-)M-. =lB C/5[HWgm=[cL3L#(h(㝇.~){}%0='TUrzWm5ҵo=t34YI :XKs{sASM[7r,y,5I>"c߅[Us/5ƙHDRyucJGg+JU>eDOut7˳U,IH-ۃ&VCA2R:b8:Mn2|̴[28w2ۤED0 _^m(Ci(nk )13i#ϯ?Y<>Y#XѭPX/4du$/- {:c|]G煺$dco0j|Fτ NWB}"/g+B:ZML[F"߹2xw= #.l3Q09AUqʆS F f9_PmεHJaXtV dk>&v -|6ƚ׶ܑ*2z/h_qU60*E_] `\/eUii:-E_}zǡZK-n >q.l]aG՞^euH/Ǜ4צˢ_WtcjMƅ#1]+h6tfxӷƭxitJO5)(X)jˠmd w_h~m(2IηjLYj Vvxm rpp)s1,#ϴ>xMx;~YoP'G]eBr"7{*?3=L& p}2a,xrog*kP!z*uVrn\%g3#ԯujpud|? ǁ +}֯#K&D 9Otr,ɧ֘Z0}UWztçZndJUG6z;1Pfii;*\ wijy0As?!k^tWAd@89~'s2ioRɲE_&jpI{ŸS6OqNg&+6ZrD8 L轵@OsS"'zcmoߟ~rI#cs>ɷG ɮ4UV,v/T9:,VcǵԱ.܊£E񶍫v#ycZZqF%TD-`pl9{łK0LzL[mX!7tk\*Ih"Uf6ϼ/d~ ~')5^@.V1UH2"hŧ >%vsi&ǜ\<5{_*ܼrRhԶDaЦYJ8Ↄ3ԥ r6]mv/yG2fI˩knXSaYb u p-Fӡk4ao7?yJ<϶NtڮEMdS|YM&#m>q .d)K-|[H 34Jں6s?[/ ,]e>ab,?l;ӗ>gt^Tv~ȋĻ* 'd:d90{43[)Č:h AG4]򥳮, wumT;":cmLߠ1Tep%{Q=MN-vQ+򅾗)sDŽ5]0$_S: )ДrO6SaAЧb~WN8$Δ-Ÿ+p2F\NJm=V O /OS-ف3(̰/ʦNN#Y? ڨUqOʙH݂4hZm=XbHD)b޹Jо 8Ç7fWq!I\aF9REaiƳ6׌w*J>6voE.r^z>P@ytS\moNh޿WQ8`LF"q\=s ;vuUVگh~P9mƝ>[.;ƽ<=G&r &>FE4 K0CŎ^;BqCRL/†HaG3g~vXwi`{X׳=Gڻ[I…]; G3aH8 l`qJQ;Yki=.5.BbwuιO'S[Ϳ:ITrzz9 mP|I!s#.퐧b8ƿX̽[ek[ ?N7pbZr!ڃPklOM>yЦ/JDMT<@ !Ѣ QMeae1ӯ-gY5 JI"N)FQ{Fe/-3"Z6X`0;t%nY_~;hc,jq mEZ<|ad4En3|}ۻT.;9m$,f 2nT$ȋ)!0悞fpZl[7MЦ辱B:+2ڂ*-2eR u-/}Ϛg (ƛq2Pvn1Zͭ:7Gm`a$4ĭǼXsopKOs + $Y.Gg?H0Y˙s8x,-Tϒ je+M;TA>!:ҖrbWfd#r歆]:8iܞz2rHR\1 Fy^6xZGf%;[-R7~Nc({| Eĩ9eTNܼmeZƛRHB浾$rѽ*ȯiUƝ XVʹ1<IճjG6Nƌ S:Ў~>Y1,ɨ>b),bsɎֽ(iL#mCz8w%`߱Gy8~[2Qo9 xʉ榩&nov6p0t|ɷb:[d"Pnѷ=Z̭iy@+V=csr7w 9bO=4-  fGp0SAfa$ߵVm]ΫsV1@*aQ3Du|/Z2pe쨹1~[ @KTQ{7cޠXךy'lo\JV2qFm5,jPeH:*vr嬘ZYk8?&XpYvLӖ·fFHgݷq^7ӏ|ޑrGPFW~'(n~q,ˠ0M*jgT|3En/+ H"M>)f R~ҫ&*x(6']zRr)$Jh,BkIi\";|wҌ<™ib 7Pg&6dRCD".ЛCHZުq&s_W?0Jr9؇ ;̱mkc=\TFOM-F:i mKǡ;#U~[60MыTϘG7Oh ֩q(gl {ݥC>f?:SB7D{8 T?lr;NzVJ;s6I<^44q\(_  endstream endobj 179 0 obj << /Length1 725 /Length2 16161 /Length3 0 /Length 16663 /Filter /FlateDecode >> stream xlc.]-\ze۶m۶mۮe۶˶97g2XcȘ3V&)#-#@YLE@ CF&djbio'bbP75(:L 0da{O'Ks 1տ5CK[K'Mٕɕ$eSS) ,))'Sڙ:\l,2ƦvΦT3{'09?̜m*br*Qaza @Ft;gM]\_l W2_N`&.#SsK;&igf`\r&fDښ(m\]L&NvqdB m-m<O?dڙCLb& .jF?pϩxʿףQ"[N&k[??XW5tqh3D=iXlFfVF35vur2s71ƪ1wUzkXh|8**#L6尅5΃ N;\ɇbxSUR*s; z7`jضr`.A ,yyc *:v֗ĩt)P~Lhj-Bn7@ nɰ-*µ 5%0Evwݪㆷ!2Wt G!oywe syTwyY|#^fu(\f)twEa`l6W\d'9&Q+-O1ۣo΋>ym )e@l]ځmڝAK%U2=1['",ݚκpv8R [2g5 y &\5_Ү#K\TEzW<2ҷJ5< UxKʠzS!O,>8c;Oz^W/MrBFN*A81u_oݭ2̽췸ڪDP0 !e 3-GK^eGqsGx^䀍^R\D K$}u󾃬?FDsuVw(BVŏbqz6+?1w~*eM^n@wתJ.ޖD:cqtzgz -U<8#)-{íAi\y-!wY}ɖX7nkK Fvg(KI N94ġBFhvvyRC8EWW2?c}aagQxb]c~E990RFD4>:+=(s qwtUm[<8"\cX`FyCrPܪsmgSiTB'vk?q';-4^ܑ&l dr1CwDwPڋ.hutJ9Ro,eE Em\9͕Z%W OIo=2=Qg9'>cn G `1L7~&96zv3CCHl ȊFg-N"}РQDU*eԢB~Jmp!%+NIiAnWO%iwI0[9^<91N/ʏ,[<,gScjEj=Z9]= Ͳcsg呇Vz 9ۋoضUK(j0p0%$9uyV |ė֙2P)M:bswmc=N̩@^t{#2FF,8$Y;(>.A>I#ūN9_L}T(qGMhѧYu۷k^م|:u,RNoXXgQdt8|cAt${ A]c -(*n&@rwaP[O+o2\7:^uaBߘR2ͭt ܪ 5ߚ#S?j7L$IK3;SAsaɃ!fES%p3iid6aKu0U˙Yg*.MR?g&O'2sʻ!A]icԸ!Ʊ${r:\i_@torڏ&cf"쑫~5']>oF(G #C+_o&װ-9n ]LͫJ^]:$4{+]^$ +ug!guCK6I3(hցAzk~jp{G*TvJ@olR'תyN&x41q@L8 4\ڠ}C$`agY$ p{lr>֫-ҩbPL;&,^Up$cu K0JMȓig4ÚoR W?hY/[Ь&UOxOkh!=P7GeûQt.>ԕgd!P\ -@?' OP_v@HH:eY,P+{P?aM|}P+jo e[ BW3f!83Ecs^ʊ,RMr?%ˠiQw'X7zwMStBufNH6G[.(fVAng*~afɦ !ƨ;EuKoUH BCp,eZoy DODeAcCCf&T= @L>`';ͩ^7n45߹&.gt@[O ق&(DSDIP*:LB}eJܕdƯ*Hehq՚[pPe(=hejP'/ [XR@0'd}>,-BΉ{p3_tc.L[=ڣx!q :U >mx&܂EC)tk2U[-zaZ(k2nT 4^w%3K3̉{4!kjJ"nۦp2qo`k/?zH.T"*=2c4q&x2SOCb^Bq$t&ʃAZ̻N_,V/ty4~>2L+/{sRJ&/MK%/۳GBfKq)*XϪkGK8][LY/W~M>T^1gޟ!ø s$Ï22g"v|˔H 瘡܂YB$\ZXAs× pec(D g"Rmg۵J3 8+{KԒ~ O^FǓ::%*{bJw܂!.)O2~k{14f܋qy\'Zj*N:jnNelZ&VdC)tRޚh{fNLjܷ/B&a68={UXY q@F\ys\qa]sޞWihvP?9r@8K#=s?U3a3uA4<+dډB>'c8XTOPŀ14"c캱o kG@,K/t[*, W b͏KkvL-%DHqRe[]&sQr> thO&)U޸Fnsm4#GT.Ljkܑ/w%&"]#:F~$ o1 Uٓ_'`- AJl}~V|x.8슴vh/@Lq{E\V|HA[tsMf%0e65VxW P ^]g3!3źt r;NNjNFV[`Q Z,o1n0b>a?PtRձ%H坫}] ϫH.(9&o@K Sj<_$q_g!sI8nⅣRcf2+DT @*O"ѿFo!p6ST^”J:Ϙ4M88 ~M9|<1A F'h&r\S#K #޸jz^cY9ҝ,|=OB^0T!eq_"S4]ίSNdk8 !EBth㯎 ۪?0Gד-1t`,x្d;<$?65l\k<ۂ.c,L¿_?˱eӼSk/Rzs@Ҥ*H{u^2Е=m\Noµ--$R}ǒYxNHdRrlЃ]uaе!8&MQ,[ߜ3/}3)M65H"RvE$71IΟ6;7u][H} z!Mփ;H]_WQ@+OrjPU 1Re\Èe]qTдϟ*8WkaoM|DsDE8,{SPq=+:ÅmĚ~ö'ttMh,@_~ud[p *Ga3wP887;S޿FR`> LF헣正e!=.e_ yVRdxoqV}7P4P^vmt!ƥsMQL.6rYb[9^=xǪmeAqJP@CcXI`VqMv1΁;KZ52a$U[9G׆qN`F^䎥Th?:;n<9Ļ a& j$!d2jԇaZ,G)EL c kpIb(&{2":$<Ņ/ `r&_Q-l|tu{hf۪=.|pԶ*|U.# 0u臜bI>9G@'2;xˢd2z|*QabSUgM^Ò{Tp]1@AުiuXpٟ'?M-lwK!+gB1?LcJ,hƙ+B#^^.Iv]LO֟|Wa]}_H 7㖲5܏XV^P^ C{xt'ܳYb] m-Zrn7c]{Dj`O/X/~[-m'.s Gl]z(SriЮA̚Ź21\,fg~ⶤxb~6N*PY0'uU%|O QpϘ`=3h'Gj9ރ#6&H^Rݘ]t> æb`6  'nYL^55ӈQ:]ҍ֢L=r2,mf\ҷOړ,Ncyb"CHnpԛpqnaoUrsK+,-R Z-gohG=Bv!-ߔ/FZ>yo:ird,mO]Q&ri?1I bRI\Iłx5Ʒ)n.6j}%&4s6Bf'~UoCyLtR9lՠQ 12^˸,߈g SbJcv/)w 7pmA÷f&A.Ye#.'0&MBа,ƑkIne_Bˠy%W^q7 |L%*{meu RERxIfLsû块e[VxޗTOtk RtuY ATBj18O^S"9L__[)jYbM}V˹`W}X-f{aϺ\jͶbْnjϬTӚ|6o|cO%x!|ǹR$[tH*_~@e*"`;I KT>B`5IwlRz7dRDM8ږ17]fA!AĄ#NEH C#F/f`t ^>?ɓ\N"v x."r]U6vG;ԘmbaMY0(Nks9iE;^I(y)[ % q줦 e\yT]{xҊz]ن=_yB~܄e%Wj#$;"ߋs-jӽ@lLbl挵8h e?{_I |s^x/4rf;vEO_|_P]MH'3ZT@0K3';KyBNWtwC<;HXih/A)yc: gBT_&/#jxJMEw/F(h Rf#yYIrZvV^*+PivLǣIx y= ,r[Co3M#&F-}T*KM^45QjRЌE<;O'r[FpO{؄qfIHPDV&ErwQ<s#3cBuz9=s-7D~Q!V%m%s=N]4h52zxOĔ)S jK_8rFqZ_t[-%F݉dy˝>1 лUƷav$zjoĺn$"1h}95 #R]<32"%c#׵P~>4+k^-WY(gjNB%^oZ+?'鳯AB@t`cz.4;,>TT=x|;nl g$lY/1e{=xr_İ%9<}&%{lre1<7i4ʎUďs]Y.6\zD8̄ yn:'!͖EGѻX5:El.'KJ1j"Kc.a[uMk,G Yb^b7Gm8Ub f 9Ԏ|; w<~$ [V%ȑ~hnQ.A $yݱjeMkM?/xۻH~8кH,V808~>:A]R)78WNWBh4r7X }AM?:Ug-3vb@zv5XDPT'|K{kZIlGr&v1K⅞%!pVq3(xT[gu~G! <̨ys6uF2$ ȗk!3fpjUE_vTPԊ>~AW> ā;돉c[ǹr>1%lc:k dN@B8NpT@eq'x%sfw-G#P'q!ZfA  :d9w)K_s!-++,2{s3 Ԇ8lm=+}B>{ZoV`DKA#L9&%[V/5muC@-&]%%bgc1Yfc?ي+,)3(e7}.ʳqQN{kr}j.6GլҏGݟuDŽr!'S ٯqx,q͂=)ioyA<اxۂC]aU+˖}HJ&Ø\4u_w߿\v0uiwZ0zm85u\l2mَiđ58ȩ9R{ySTm+Z^9Ow򴥉2f+һb]obͦ>%] 2R5X3%z󙮴0)^\M]@S3=,Cro3tá٘ߐA3t<ȁh")gxB0~Or:,R*bD{srF͵ڍ&[I ,P\HWե֝]x/G} Zm|j r"'rQbⲄTA̜hq1OeYr^5Vط#Gd.tk׸tw">,Z,9'#d, cddGVOYJ˅Ey٣ptK 5m3}C-#Mi)EK³{ L,PӶI =D- ``Xx6>!LF]YQ23<`l ga:e`}3+o"}/FtR6vZ 8WGY:S6-07,%Ke2au?,V؞:i\K{Np&awN}sG$][8*8#yif\ji>WN/_g?ҁ3<aio?XMİDrc)@ zl}Ob؎ [؂SцͷN)=%h$]m=a,M]DK*E:! [yMKԸFd$F\ 1 0aYu6߁"W+zs &ۃUᴍ&5zٯKcuq+AuͩdDJ#A<:6'ZW 8705gnHN>4x[ yN-_d Gk&Q.|[K$l${"*5!qSNKOeKk׭1>cll!2 d398)-e-9x[Yz5(@_ɜL} 7Q`syl-wJw 6"/hGA/@Òάo=4Wt c?~;}ت뤍=3EAlq%~ ˡ2hA:S=$9d\`>\IUf}X(ŵA13eA0%Kcu5]Q}\{ث6ș1 WkXKjm__ޡ$fkD?m 7e. >`.}U8Fai!apww8h’ާK sRyXlu%fr~!.U-qIr] ro񻮊 #MX,1^  ʺg45WcFQ-JXܐ7z Fᚢ ƁzlV=x҄X/[!Skrw~N]8UDCcg\kr"z)[Ml{M]%iTxFL@r괛j5 W֫{y c[=g#m %;ۥWsF-T(t\Ae/A<s$QO IGQQ'H+Ri8aM]>):wvVE#GKڎ&&dH@V{"qù@Cw ;N"1= Dm֮{kavzY ~JDlCiK* ?ـ" }%Yto=$ ^o]7U9|2oZƒ >˚_X))ˠ h0$P}:/7w-!i/IbTV!)?@DLlrنb@G<CSU v(FbQ tmPGE^'?/fރy+?^+Q*zw]4h-~t+9ݮ[ zpn3j"5Y(S,kvmu9#X ä9À \#HYd5HDbԿԣhL`y"*iH34e)<Δ Zn(}?E;7_U{w]>[-Μ~c~)Lz>3> 6?/P}pMv\ hu,'%Be_$nJ' 'mer 5:FH@fOIhYHy)lM\-$LCi0:=s`+4ӈCz%v΀oJLMn:rpkP,}~͸eeWPv5c{D&[7硼fs刀~q~c}}*y-7-jv8⢜LyOvUKF+h>wyShQPeP}m?ҟ\AIAv[B$=#Cfׅ\gH{=:&Fӄ?X[_L8RU."`kF#'Da&[|U 4ץkdM}AM 4+"%[j;c;5 jQXlS(nfwZցgw aYL6ZU̢Upܱ/Ęc}b&Dqy{ 粖?m7?ඹe^ҿ9D(.j竼T9o6-,}H2SL((eMU+qQ6TGp4CPEp MA!YAEW#:PMg ] :OCnV:W=L ~9DnSt4hVU/& pE?˝i4#[K j=4> endobj 137 0 obj << /Type /ObjStm /N 72 /First 645 /Length 3541 /Filter /FlateDecode >> stream x[Ys8~ׯ58*5U>5T--6wdCR9o7$%ŲS;F_7Fa@(o) : >RB4"`㔄Ab0F#*t8)0_Bi"0#@P#H 0$ "E@ H*ԁ8@* TD Aqet4r-QHh V+ \6,¼o4RMFak1JQ3JR1!XnaQ)q 9kZ 0AiF Lq$V0ŐX <2$6]Cd 8q+W44 pj# (BE)3v 'DG9GS*jG 5KGwP#ŋfeE@4:! Π HP^KCfǧ~<'e1 ;{HL}X>~"4`O!Dr\aQn)k;hS)%;a3k錿ƶ(8|w}5>cиkR6̨)5 C>n* Ƭj݈?cQ@ryĐB mtL-Z-AGCe5_ٵw.qEt%CֈGgPdyXfP">R(kyhXGR; n(57 p}E0R5~4bTLGr**ȖJ U]1f\5V*2V ;u$N)9UVBY(;ܞUF kz+휄9pWh-tAfWC=+ buk&xqmT1f!i0 q7S~ 5ܺQt*gW^TFІ}ߜGDjȢ`@͵nDY **Jbғ YK%/n$mN6;JnGÉ=6s}r혿GM՚}`rt?&BԍsKRNV?PcQ{qõcYʔ=U5MlBiUT:U5* sz? o/&:ܠ@3vs )mK*]OcyY:l>1hݱ(vO>izB`֋J́TpD.tXg{=ncv%φ [egU|p> 컆}I|3[N~>ޢ!O"`k+||.Yܾ)E>f1If%b7"$G-Gse"J)jظ3^J&'ymo_9?EŮekߏp--qsL 9|ZH134\/6:UC WrEL?tl{oM7KL7\~o#6qwM٪F]&y]{վ{@uryC6YגKÒ }?BN8>ZgPQ"6>F?\mQã&!'%*ZuH\O!p1O^;تrK<2ol4Iju\+Kp,OJg;'eu;9!$.&i:I] ş$.1Ɠ?YAi*N=hW9n&'EW2˦[l,f㣸L"]9os+HcPL>q`x===_jYt$s4w, 1uz dC8pcAyfǁ@GlhY>dfVL#k ٷQ tb.OL;d1_f^/ Ҿ"}<:3d9eh*@ dEՂ yt3ue'e -F}WׇO^Y毫{OJU WݵesQN^6"&9ήHjb8%nn>ndi _됭 endstream endobj 196 0 obj << /Type /XRef /Index [0 197] /Size 197 /W [1 3 1] /Root 194 0 R /Info 195 0 R /ID [<85801C2BCCA0317A78356FB5AED71DEA> <85801C2BCCA0317A78356FB5AED71DEA>] /Length 479 /Filter /FlateDecode >> stream xIRTQE3QKiTJE-@)f`9b# wCɉ_ffY2ڪa=㘃2P)pN`gY(4yjX"* `mUj[j7Pq ʠ t` "BvpC6>]c.䊓~}W1=Re[nG/&AEtŚ̀QRQ 4tx &i{f Ps?V90 ` x^ >nzށ5>^O7&d_WϺX 1c A R.Z a䶼~yzY*kv݇Zܷe{6?e'JItx*J NO?deO?3Y_2>H 3 } *T0РoӊYʋYeUX endstream endobj startxref 207433 %%EOF Rdpack/inst/doc/Inserting_figures_and_evaluated_examples.pdf0000644000175000017500000037033614203665044024305 0ustar nileshnilesh%PDF-1.5 % 23 0 obj << /Length 2948 /Filter /FlateDecode >> stream xڽَ}Hl΅k(Wb꺫4Y'i"狛W6KtyrsV(`gqz̝E֌rQOЊZsjt V`U0 ~]ki5/J>+d=~! iY,ilWW 俧Z魗DФC4o_qW{[F3C|np~^Zx"ڂGBӲyzoEp m{qJp#sGTʔ\630.w}؊gmH&LLWdv2 wd|HxD4)pп.'d,q0VKwp Bb&ֹv!“y;dqE ۅwg%\JhY=D+b"˽lpLG∃0,RtɞS$~pzq#lt +2U؋s,^:qzĹz; ҙ LJD b 3M3rw. 0HpKUڌ|ӡ=8[L9$xr@C}ǽ f%9 . Y FL WUJiR(&frZ<@\ 耥 m?^ ~~vfb| fx/sQlBu֑4~91Kg.Go͆8$3?΍ U^gM ӛyuc= َCaziLu>U${ƹq{$݉uYTip$9cJ]ㅭg^d$AkZ[U#EMQಧfvzѮz|mcI2} r1 +{%8WyQEѻ :ĈƮ> =`Д,r-< }+UI|*;`QJWxT.k.mӔI?kq?1 2ŧUHWhM,2Ujؔr9 YS2"X(=.yp+ \6p%?$9 L_tT!t'T] 78FBnFc!t]`VRB H "[dutnB!}=djK0޾|~:$HMH#E{6#e7b#= eه^.xpOxA!$ !G5(Tu)EC7(L^"0R,KL/Ϯ[i}>xe642sÂ!]҈ mMFW`t+4\jMtp9Tqv$lg+wB7Io"]Ő119"$j+rP endstream endobj 44 0 obj << /Length 3538 /Filter /FlateDecode >> stream xڵn_!$"'Kf(zC6Dɪ%Q!u"sRw9Ù3~0mfoWy{u93qTŕ]ϲ<+;+,*jv5q\^C74ieYk3ם~8^Xkbn8=v2o_gȹ:qX?_.ɅI<͢2wƦ %h~?~h; ~O׋,0&N~ ?LI8eRWBj<=n|oO| F;]/#BCO <Ѱ^NrHC2Բ[+ז("1?Ng̖ Wr6EFY( KxK@ҩUIa_OX$ދ>ڤy94Ƞ#N 'Ӽ` N.U'/+G\y*Kr,m'D}aht-Ϟܢ.b+nۋPZpB>"2 B4lR.Ɖv6 |R[zQd)0=aTQ;zblTV¼#AY9{K8n+=&V^ f]J$BXxYhHl<+َ<2I9Q*0<J‚/,IPZY< vd y qSo{^qϝh,LQFƳKV!2+<#7|GX< Cg'Yp& D*ے@4:|}csGS^Qivg1 ؐBS( ʆ)ܸ# kCj]07]jxS^UlBsO:u힄*7v bїM1; Acd3?"$ʕ` 땮+X H彼rZ$5H|Qg Q`B}DVQT1wi4 p YbodFy&SY9 $NLRd@!b,*>NK"k ŃbSRMȄ˨4"ލڛ>,Z:dD4ϰO )\7إe1[R o@iI$7$܌˃`Q4BW ː8ȱ5Z/C>[3\E b}vo~kq6sⵔtH 0 IjyACaǻAG'3l${z+e (ZB9(͋0AL}OthxV큌8"SB/Т Ҿfπz[0 5sҴ$Cg¾ Er^=kϘ]^ y_LpXضp&u9[_mu ʦێX gȿ&ȔƠ,*0tU*hXHR%lL C+cއS2NI '㸳Ϝ嬅8DZmcVPR s-jI*>+ FDU|mԆY=Ėc]a5= BdzW kO"]7ZOBW*qYJ#TAϧ<-B-m0\I67.$vP̸ "c5$L}JPh1d 4 c"P2q37bÿ C f.Y!FҨq)beE$[Ϻ7h^%Ҟ(4"ûuBZv if'5* p.+PL+NUԳjʟC\S/^=TlسWꉱ-XʊA`DcRqn2HM.y1Q+.I'sFerV.}"^W/;ש{uS d<?r4(~+C%_U&-W?V0Y* p?3Uijտ2 DUQT)Ӕ* ei9+ ZT 6_TIWV+V,lSwP<"$\L=R_ +6 ƙ/L^%"S \*N+% >* ~|DjHxT=׃<[\0uƬ . >+CY#"ϪcuE]ǔ&s R;S%=S˜5U$LIl{+%|Wk,7S+RNoؔW~MxIDqQ6A g5;3,PCMZrtw ݮ!K@_/\xR 4tVVoy.ɋ4]`|l^q"' ª#b/O'LGFC]C9V͗tBq.QL" 5\xr5ZV zi2 9-z(5wp:j~UF<őZQ;d515S})(KrFn0vUxHb8$I6M4W*8_,]0CPk#x 4&y>4#Q>\+{it)|bt@e[ޙeF̆8' endstream endobj 54 0 obj << /Length 380 /Filter /FlateDecode >> stream xڥRMO0 WJk4M$6 Ƈ}hApc'7qb='1#+^4T9,X8Q+*IS Wzv B!b*f .A:S<W0;!9Ui R`\#P 9ͥ19L2NBL)[r*@y@~#!O?.`H{)$1:;ˢƴf]y1.69o $,ìvGTjiB#F9*j IsyerkuM+ƅ{،{k&]*!>ٹTU+[طź6fc].7i};=e}y endstream endobj 65 0 obj << /Length1 1903 /Length2 12669 /Length3 0 /Length 13846 /Filter /FlateDecode >> stream xڍP\k.Bp% 6%8 !X];!eW[S5֧~gQj0Y@AWfv68;Zj[B rvCe 2s}I)AnvvN;; !I3w@ qPK@V֮i@29f%3WkkF@\++ J v\@ AUƂB д%׀Xz9;0`r&h)TA+e7v@`?̀@ ` TY\=]fٹ@^vf27H^ <3ՅlGy?I3v/ֿN7;XXQ# $'ɫ9@@k?kz9T)~|-n ?+,@W9 OW1/z`Ou, v^y r U8`f}}0fiWk@r;2ujAܐ <MQoC ISQك6xZ7P6;s5{]1+4" Y]_r?vRTllKX@׋u T^SJ9!,7 _7u-@0x-` qFUjgz~!vmb|erX--Wl<_ͭ_oW\__7_,_wjO/+/ԯw|] ȿWj.t53sk-n W^=5t@7g[Ku"yŃ@ ,(b-ZȃykN:=ςs=b }UVЪX`ݕ"ٓAsb$Gw}? j{I5E}|ma?;azx~Y RۮQ@}2cX2Mg=OLĀ}9}u=L>0G7G݌WM*}|+ Ty9s9Czg (>;1 Plǡf:i*hhj|BKe,*)KMwO$mZ팬wbh 4X)EB99+|O д#p8*6d}H˪_M=oiGjݎre@}o%ۂ] 5:2X-"=3+47nŸL8G:Q^k rG;~0%gm3j&33:c`RćM7Q /`evz^x7:(Xp QFrAgto!?n 8[{"s/z~k]ʝp1i'Ae|0'n^}Q,lZ?7:rq+o R d;׭FOi %BlI}17v/M]-[w̝I_Z%;1T s#BFX:(~nNvSLz#5맣S%y.0}xKnX`'rKeER̩^l\M#aMs{r\Xњ/wk^-z+ʿK0XEۙWL5. ah.mE+>_}dUކ֓>ґ7rb΅C[Ѿ_APSC;*zj|<:(텻TSM߅Y*^|h@PZKKiam=+)S3fjm"D Ih2x븝Zաx kL.|%P"xEΒh,pqEOmkhn CQ){p~SoېOD<Ӊ+D/J"w^C!d ̈́_w% ĻֲQٝslk^f588kL |>Hkj>E^iݤN߇pǘ^c3Ȼ~S yW8Mc!Mf39C\*`7& g |LY 貶 ;QYkkOY&-.R-4av`p<ؗ2"6 hTȡ z>s]>-.2&; H}4hzAd4rh>߈nuJ.S`EH#-(pQ&s@)لgT3M;u::O?^d qSB;˽0?kF2؊%1W! z/#8+[>3J|G8E!/_-8FFRK)CZ-=] zQ҃@Ud3+D0H3@%j;7v%_,H/!OhqxVG}ȩG\JV!b{JDfU3.qEX= Wwo9's*'v3A92ESS hP`t<|&zaIS*ed@K;Yao]>^71rS*Ato4` 4yKm`>a!E@gr+r [-y$*ݤh:ja_,ZC GO7]oC;NA0qYuI -(LuфF_i:K擵ϲK!3|F~_ [;!Alm>!$}8p/9PlUkNԸFJ x|-Yf&7a]3`w_c.3P$GSq6ZlF#4=ΑZCHfܲ49s|R NЧb%m?6_m$79͵-ܒ 7.(3B _`ʨざmR*" {X̌ɑTq3ɺSNx5GI==&ew" ]f_M)?Ycr#=߽pЕ9Pb?L+}c>&g+FEyB!u݊pK/Bb2\ Wt+7@#8ibJa=}uGz<~n?c2tO QsϮD˷lŠw5q1hJvQg^0ދNY%Q(nDο1pt:<A'JK,<<LV¹ gvޓE"Yrx;W"j"m ,&!֘2]Y66etEP˺4"w ᵑ(Ym$ ڢ|Rii E{6 i0K#̦dUܪ7j:ZCy>lP)Er?k> 18I/^-;ȒT`A sq彬(3iׯWn#N |{ ,yL) &EuǏdzwD&iS8@u,-זG[Mo[ń B7Hsf+߹}s e\!-VQeMh1)eZ_'0'SJhdN l/?)4`ƺ|V嗦vq.AIaERaǠ+Suf97AD0sN/ߜoKli HC]iU%W>;w6|bF{`5meĨ6@ln'o@$X N6ڪ.T s]o"pDj2懄IC|q co^kK-/.LBeMO}Do,LqdvJi$;V"fUzR|٫E.}RMpd@mga/mRTvC/i "orJ]FipMYKP_^voS2vj}̽bֆ֬2$SkLZCR4%'ηe[0t(QX (EHr[|\xgL"soRanRST:UNy'`-m`:4C} PI8KQ\#/> "' Y{OeߔIXmE-%mڛ?_9hok_r4Sz^2]H+u*Z[ʎL '/-">cs\Eߩo͆p\@ Aܵ,oυSfSһl& (zkf,Dװ%F />ʼn$%&ser>P c&eOp&%HpSj]g43&Ta+= VZ&Z~/'niEs9?p;zM媂#ȫzX;{RV?fs<-l^IGVX#17.ٲc-jO*NIػbOGl:ZZj#kYsfE6#[+YL\kB0>!z FYTOHQL A MbP'o}nT4ʸr0vAn#4(1;olRx>kus1'O\DJ_~A &Qwq`~M.i1Q#uq1i*<@R Rk`?KCVد~RoDNu {׻Ĵی(Qj'ǣx0x~qÝImL[ 2i @6igf[QU/3e[Yя59X2t’i,kVیV$N˻ ?l`l;oKxrZ_% 3OUZEJ\?0)BV^ x2?mӣԁVOjK%`o9,aoQoS<܂EV eaF;:t@߹3^BT`i\rl;̙ tv7b.Rv? n(GNH Fp֌DL_G?W_ܽ `7JYm &~ hy_}Jc?QQdL2|SLPR Be{>\U`ee. x`u͡?]~?Of'%̓!\׻EFc˴otQ;퍅હ l׮1L=4 t4Ku r)O9Sȇ-ͯr|M-ܟqnDq~pJS/DfIDH@ G]^A"^Ej&!~rˇ[C>DT}2k"24m94HroA߸nB 5DƵBSotz8oVmKޛ-; hcίĐ{%(d&b@IB6A $V&e"Ҋ *'i جmxa`\)u&Χs )ʗV > 0t'WWο3$&3 *-&QKOQ_>}QJe]~I C!^Vh|D"o4'؝%s&$Mݰ-NCQX&֎芥>{7Z-S+uyD[ȉnkm\ԥsgUb?hV=L52E&V$M%ey_&ސ H>hitF')QݻBЋdW܅u9`Hovx RƿFQ-WE^ٗ,b?_oL 2n*,|%P7` @6úTzsO0"\Co\t,,6޼lpdfJlM{A5u-ai@riiSj,m7j sarBNҽb?׉o^UU$"{#3LF+dl0-)gGo#mIJ#o8j8< DT _im`w=ntҜ6=ԮG[<vW.}L *YBiS0CIYH'}n`{ѮvT%`AbZjOBA;(,IBuAGЯ*ѧ\Os.#0C <-*Zᤙ {Ur|.{ ft5P|lYP0_{z=ĵڦ= V%I)fZQl+Ly򫏿E_\dšr̴(o XUցvWMf'I)ޔ~7Lb[wBu`xS 㗆H%Mj6?g8L"}xئ6re]vt>_(*|0YEWCg=1k?8Q3w/IK8S)nqE䉜SGU? Cqڙٝ8L;=uNQyp{w} Fċ~)Fc˜zIC [eG>e$w!#0駓.;.fw)+H/ ?P.13x[ܲ }9.dû9CvI@2I PtlS=shߴ-F w3qcIҡFFXtn| NX,jhpij:MHxO׵-m-έT. o7ilaIqaݮ\ V4$_O;%)&2k+Aƕi9edZك&c ͉\tH9U_At!1;@FhH͓w{K GǺ|J=FiFT\1Ԭ$q*'LfD~x[%*cD8VoX$NPBN|"e9+;f~ј&Ip/GEW0Y8i54ϻrre{'ڢ=gIV!uo[G6Ujw,t-i]<ݢPdНd7 aOИˉC&kD@[JY%Ni3K<&zKj5 %EGA=D?F{Y!I02iV[wr:v0qF|;$} PZռçHXBBCNPHdzAP\JβO3Ϊ+WԾěnսFproL5-L#yjI%!XY@ wM|d\/6Ƹ/$w7?$Jf_0=̝*i#2yF6T|iHndSk)yC8ڠ0gknMô6L o[Y\eN{THu;`2/q?z=ؤyC{*v}L;QX] -a2}΋)"8'CE0ݑ:eea7_>zzm!'<[EvGa©`rr&g S`m0- R{4^0(l'qLfYa}iyb.:Cc#)pڴ͌ 6""SjSNģyK_!ݰސ}h[yʫ+F^GH %5"p[~"#ˍ#x-_2m҆& , }(P A˧Tjvj+#4^_IpEӹcߋ;mh?-/RΜ锍~`>Ir4N}d$izQZe$n E[L(kj_jw^ ͋@\IͷL*-+~:##[GE*3v ٨vR4{9CkĵH؀m#utb9;M~*k"ޮ;֊C:y"+%8 -jE[buRBXP{fJ Zmi5"ކO*ɄwurkZs㓱\ZP8iL( δhMt/KEPJ`XP-Sױ^uF m/?'Tz+y~4ڱ%WqE}23+xe}_}.ۍۻI?OuxM;Q"峆)U` e/q:ۇ< f/c֪ĐR+7rMlʅ)ƻ3+nZO;:b\BƑ5嶃œJַSQ}ǖ]7 Ň4ʼn#D,֥B=BTvaK8ZبDݐ6EzU%ӂxp\: 5K 0I°{ 7:-#^^^=G!# &_fmU.8+^<ٞQ,a~yvP C7J$> stream xڌt]mרNضۍc6il1ضmc32κ&99"'VT258330D>13XXU̝Հ6<8 eNvr6ig+3+ ?<Qsc@G.bk`njTFfnnNB@s#=@_!̜x]]] lL?R\͝@1ூ*c#;#W5qr5pVF@wgc=9@YJ`X:030'ܿ2`bn(289 l24r}7p1020|7q!%{h`nhnWyﲘ5;Zغx &6&alǨjcn ][f t311qr_U+Wigk0y/en|h898`TMU{>;솿=]gdk~e#acKbmd4{ߏlߕ&_JB[g?K4߳>{fvf@?,e{--ڭ8{]#ڼZlV{XM~Kvo ?e7 hlh߾j[Gcgmbt2s})\mpxoI?o7rvx߯ fmx-j>O\phw~DNL_sJFY\$zٯ 짿 Nnj]OԕFL+ly' iS(B i!Ǽ t=EWy|4꜕+N[|\3V1`49єJ5r,bw"ٸM6)0mw̧fWU \q&a gCj%v\q)1\;K,"#r47y983>@bI:LLyݺξzkٟj)kIVV>c1^I?ei2 Gxr$jRIXq2T&5eep%~x|l#$p_B aQ`RKR$#z:x,k^9  Q&VzI9z˕x:ǥdLsФ"u#Nq-Z͓I25v}nTN!P5{drFm,-Ҕ?p;;&XFeO,km$t BA!sݜt0'84_]D|QF^%[l_iEWƢdy q~L/퍗6%fao@)ZA@IqT Gl ty^>,lNy|XAnIhG'7+Eм +wihqK>؝#ő|(!!.>V{;su ;L~2W\TFsXIgXLn8^!ɂ,VP8wKl'f! ;1-d%1$mwsǟ#C@) x nLu W(X\ъ^Í_FOt KFP$8,DީUDKm6jP{I9dݠsA3hg.-C$Wk<^SF~m\2pD_2Of _59eLvme7-۩c"Fwե5pV⻟7i0""DF0 >wm LOhVNQ@kBBGVǵ0ԛ@k2:^@W#Q3$+Ee  f.G w&.i)usGVS]Y"( ,Vx,()Åa1L<aeXl@+^эW2(!s,&: 56T=shʉ=wGNVᗫzGFӰSb7L%:$Z\#}M~Sԝ ʸ7 / K|Ub^M! k)˚h{+;5%gy !"u '5Aƒ}V&c?g4JZl9b:`-'2t\LXH$[LPLl{74 nI*KR$AŝB]l@2ԪKX ʅ۶x.h12! ^gn0x%*"(NB-ߣ4s&PW}zol쭏ԅ# 8 W|"{hݔnrAY&#[.A^1cO Ty!h=Uu!_jPVK"c|`eZ'Gu tInFbI A~ Uz5Ns͔bcτ\(ogv~fG i[v\dI+Wp&^F=]/+:3;TA;wy$/;z* ~jPX˜{%xB7.z=2$?kGw"{lt'Wlj`ǩ8ZhƐǢb #0ߚ\3 xlpvB;`̀F9-:`Ly3+R[g}PP)̮'}_\1 9y&TII)cQ܃d-/{)TQ+ĶP&sove$-Ot1!@*}I fAIPw7=n8@^b mWӡM0yRTIom(K:꽾vznuǸjFҶ}=KgqYo0|/sv9t._w)cēyZ bVhdǰXf^+^]KY@l4/U{COya;^}>nȻg );6!Qߘlh<*>{\'D شuBdG/;A1~&_WDޭ{cȱDWkW8E&AKm$ Ua<&LMG bij'Rz5WJiMo4Xtc؊$SGr.Sue5TO 9?S_Hd qxcdqz~p)}Ҹ3+N|{yE_(;2pA9CB#̉ԹIX yfH@1 /@[m&I>gåFOE+Nl=41㻞qlc5 Y:=,G2u]Ʀb[P>䲇τeNw@Դ}y|frmr޼7'j3_[Z4&8 b Ûༀ}ˋKP #j"UnD{{ӝ'Mr (<22CuА׍)HydI:tUn\7fԛgY]:V(Z{9(tEaJ]R#D*<'g{o]+L|eԭfP~l&⢍fK *`ԺʐA6^/t0E@+5#?A=oY&N^_57Žܺ"U3SjJ"΢pHk-~|R{8SM#5UM9 sƪ1-n>tVZ,& Y ѕ=4ϺiAs2f|Az-"}` gIݒK/A^y3ua<&%3m߻XϢgϕYzqcgj㟥ӵk/q|@r`Osx ì蜨xv馓! {Y49M)NkyOKqI|DuYX;>4$g7t_me[װXj  UvO!OPޣQWL+d,%A1 y%,] fOwnE@yG1|BD2wv|rXe~\R Ds[}F|ML.vN'uPf 9R.qO‧qD !- C//e+~E,*6%;OZl_8J7t*d+EyɝgZ!wiԻsG¤SLpDbQ%)ɓmƶf}"J6;pþtHfZX" }Y Y_^_ux"eʹư!7hFf ~`~g.H%7ڳF:=YT~V8iO"Q.2^:M?^%L(H:<ǃ>(~XHjZA{$2YaB_^+&y+ܐGnRUwYCsRNu`o R͕-lrzF0'b<;P#*mRa0[Ô+p )ij ./[]N[R wF:WjB٩ zS%^韬zL!_?z;pDϺk/bZ5kl'h0|M]V1?9¥CX?˽ eY-V(Cly +XD%RX7}pRX@OC_CH=w&l-3[PI/v&6yi0J9zc1r ~ד<&XE唢iS#gӋ/Y֫#oULH_^S||\vR٘Тz ,D[WQͣﻌ-I1s2L-2bӻ^Ab׮yvN3=͉|8o}٢Tќ$$M:=V|W{ 2D$:KKg=T-B6jexP|jn+=@܏ωm/SV*PρRA+(T٩Mѫ+k]uਈ FN.}& `CcFYꥦfNw&VfluYqGC}#mM!}]+wBb33u؆q7t~RUu(RM$vg iHr*) 9Fcz:mYb%H1ʝmY)(Ld鎞vѲ c::>-G缈;q0e୽9*@;]gqx8[b=`<۷0P9Z;IQЁ;ǘ]Zh^{3L΀dV7RQ-p\JaUP@fI `V^) +\(>'(۫VIE|kkowt힙bJē,gp*_!X7d߯)4]lhPE~8:؜#˥ Gt{<) kֻ_rr%Q6}촶0G^R͑[YptFz7Lp"B:O@†nE񖠋)'=ͪg]푶 WA֬&񪪢_Z,X`" O e} *C~|116%Q4[F[ط+Uȯ %E9͊Efs} >ZysNùߚ1%:}~R(CՁNcO`%wDO918/E{{4ri"B2Kbe|%6QR{uǟ >ch2?yj*u$.OW&B\-2->(6si}4W9BU [5Qnz\{~O5`T3ߟqK_A X ~ha$: fxC1)+3 3[OluyQYz_1Z$d2LYwDb<_}"gg|K7}^|Tp揆"$mޤO%~{udU`0:J͹ǹۋTLnׂ4+ @6HJ8tI)yAZkIr QNpQB=ʸ[`tw(Tlql5c})jVkA8|}e,_ ڷUZy mF6]!{![*X堺"p]WHOƾ/cAY4d̈́f)*1i=[JJ оXs0Z :V&-%]Xu5?fȁbNmt[5agtS2G@6%lMGe1h s9_ , ͞}84|&&a eƳ$S`no)(syޡ2 ~K5}P% Y?!^Zy x |y44Pg6%CJl$DbVN JOE9}|N? $AQPphyNr pyGҌ ekC5<+_Ϸ:BOP g;F}oZ6|*7ɚ@5-/'A>-S4JIqy%VfODeTI<7ē2oƻCWk FVEW Zȼ7 b}&yjL=tgu6he$羧7H)"Q&*&T*Q%& 3r)9NS=ծSQhZʛÙnZ@]^L Z(uO l-$P5Dp!a_YnfuJc4{4l_(b9/u](w%R*d`vh3L"esO3980<3 uA8T~~TT;DNV"&i&jdA,ԏ4Z. 6H)5EhhOzkļ[ Jl9dөkˡ HwtdCg-&xNɸO`;le`hh!/9ۢ6"Aڨz)]r,ܚnes) f# n-Wvrtw_CV0;1:gnD>d88>1`F/^<:xO 9t1yn@iDI0Fw'?=`7W j~ݲT]̽oWcv{.4'wTnt_SWsQl" `{E=<6} Rju1]9s!-aA:utVDjj.ɺ)ʂJĝqQx>b^Sh7\g U r289;jϭpdܐ%w۵Nte2SEy}TPk8LzL`4uvA3C=yzF<p MG }Ĭgj~]}0W7h8 "ðe|g嵣|kf6ԕa7,- )$@Z@f %E`G)b֤*ъ "6AyHbZO[zCG5 QM6DMlJ.'w*Whjd H3Z4M5mxa&R{+CMX/&0ȕ\ 0`rVtsyL^}|m@ky]kuѤ!sTy/iNLU}x%TCW0OW=7tW?i~SG -0B<2^l zn] {$ŃZޤ`R`*1bf[|78BGVY)WSGJlU-HÄ7?KI3Q@OzJ`2yeS4/#}/qvC,yU2cŘxjK&]+AWi<A q&yiaw:,Bjwo=_hg:KPs7 sg!mYX*lЮ #ٺ4,H<XGa0C[ ϼwZ=T"V%*iCwvvWQ O傆I jfO;Lt05TPuXJ$l^`fᑤK ,WbO`HW1Q|hqPagZa:+WyB~Rn"ܵq9_ { ?҈5L_Ul"J_0?#i35?$UG if!˗k_4 AG\rP*@Qtx׀ t[W7 ~8&WCyHE%͉)ot A 10y~y[S3^ya֓ +DӔ^zOX喑˰,x$ufe%^tRݗoMY=1}A(wӸyf۞:5Sp%ĩSf'>TU D;9)1̡;7/S[$O{9(&e#\s@`^{eDO+ MFL\Houf~#O .mZ VN'kai-!cTN~w Ñ)2!-j-5KGqANwk.T YD#@Vȍ/ zȗˉ#4ޛY}d!):;Ji?JbxD=y) 돿 x>{BôPWHG#Qʢ bK,'کg%>pw ucS?N Q}!s`П@qEg-@%@o"7íI}r!BS֧Lқ16vtF24B2%BLsސx3Qy'(uObzp3u4 :kЭD3K6WWv, m>9s`!ImL0,Kvat>+ ϙoa]{nH;w$^Þ0-֪>(fс$9 4vW>ٳG¶ٕĚbB5pwhFe/ i)s04e`:5 L;NBY z-բW{_5| |?Ž<]}٣6HOCPREAxn| ÛsX>Drj9 &Ζhn$rL9b&F< ,v3ؽ*|S,魂m]`paOl! όVX.?\N`- ;19޸Z #*3,>r\5Jf0дAr8, aQ0)rO]|QGrå`!ZB"`s ʲtʵ2X_ى:px>op V(_iW.NDʦ;H ]d)$J'm7soTN# Qjr՟ŏG?vw$AW'dW /ݝbp\š2fFjLG8r1Sܫ-[7QϪUV;U|23I*fޜ;*\[,pSv) naDCCAe9X4%Rs}aGFG!Ӣv*vJ,Ŭ$!z[XKv[:Yp[h/ |g<:,4 XSCgU}{G% 8^uAl#vG;\v-{u k7l\j/8t4^Z fG}}>̭`j2k=ʞK씑-bEedT Up ǰ nւ˾Z$ו^>F?<_1[I~H0sOK&EbX6ato`rLizONKs݁%\PI?ib{@(!ß?Tws giBdZؙu@ կwr 1Eq=u{ @DĠ2EU:W[Tg irJ \䂸6@{1I/1L I<:K*%L"d$>VIE6Ƅ< 1M }\S}2fU}R'Iuٕg4:j'p?xU 82!X* XjȾ8?=3AF[mccMxz*6F?橯#8FXr*+ 'T0>t_E#NsZUP?pfbWl\YgC$IK1U~eۻIkdv0eJ\#)L/^`[:&^ 'hM'!l=PYrpРy q?X:ͬ(X~ LZfx߽ 4IxyC>n̒suKZBu꒹ WX L;ZuDi]_l! ?6G᝞h{Jԥ`Xg\w/lU )5 fLsz!pt_x"~vb.SK2oWZ]2Ω(5\T32}Ȋl B(K1rd{lӅ~D6M?A6gax@-9C,1NfiكY'ϯȜZ9ckzε^Xɂň~|[ۭzY$ n[ 4W8W/>`  *DΠ(^GeПwtq|^ '9J?#D=ih< AdJ)t{)rF)r,%_ӫCy^rbalTP5՝-OniMtaJ#EE"R|Q}كz:Ivoj.^jќ(fj^:Y rA:p(`q 5dz5\;I.Ns/Z"+ⶌæH,|CKF/‡ڐ~Rxn>corGr\y~SiE}{'`p>g:;3KBmµv =gw7~譴tq'0|Sa (.y-'-W9Vi*Kȭ+}o۝ BU4lNaQF9(9fcBbx>c4c|.4a %_ȿ'5%𹕠bTpC$"B6;g1|C 7mw<#L;FxUĨFPPXv| 1[fؠaݨ2F̯? ^tD a4NΐƓzomeb%ԘoYgVĜVY+Ab~ ,>  S)zGi%O;9%2r p]nXw$ė/w?C 'Ӟ^$'E_i>gecA)07xeWX(rJ#j;>w[%B8d1vmSRIZMG.`kI8tw%qgU F,Y z𲍣MjP!!¦$WTg>$QxMMi!uO\aQf04W_#VK+DˏLH'?ZWQhk5 ND9} îv>en_mGe@ftJv%s |m\Vw3f _.l9LSP'U5^"\9X*K]`F|nx&t\)tmo;{-0:jC쟖SXJ7\ȹhۚybsVv՞o a EͲМ7|X_O/6i{?lAڢNOoZGׁV5Ѳd.sqUFS4;oJc[g[>w@߮B2+4:XgkMֹĽк-ڋX(gҗ`-?ozzY.ɣ/‘fJсZ6VW d9q -q/ u6 P$@ n嚈Ѷhe'xyU@%x9D^QVLj;*܂$%xۭ"1?O-ʴ\F[d#of@jt4JA#;FxѕUhnU%JUq7\ 5[~ ,Ō9͹J.I%A^&xI0b7oN$W,"T!Ej=^+E_~E}8]ʎҭ@xE˰'hOɂ%*CʅuXp_m4hr߰;=3+Tvěc;!yZ=c8dLw_ Y3?(N|qCWUa!З̔!u>B~b2@AJrzqQ[)_5FP`x'hcHhJ+p:֋R D:>RxشS;X1cڼM'oS/%B% ՘ K]7'ia>h̑R^'.a@ӝVa+Nʭe]"9u]p&^d)Xޘmfjvs{gKP'e?XQnI2Լ *-2`ۧD^'wZ lؓ(܎a%a!6q@շ8 rM~z_+r1'g'i05ZhUiz|~ŦEHWYndA>ff`͈wAl\hf6ŭԢN{AWWkXڱLTuCäf)MͯZR,TxOao0'"ZOt!#74CJ2wV!P-<{]DJ //-[XB'Ϸ`jroNN L2yjg8q !d=B_@\Qa6(óE"1%$UIE[9y9:6+E` jsu2mnt1+ M%($nշ3LVC>nn1>?KLkm3aA)c#,;X͸OvΫCh 4z=n9U^6tkJ*&phڌ#Op> ƥ8 bVaLM5=j̈L0CN>(yeP=i"\wI3ajG2I߆ FpôIř.gpaIԤ9&Q˭27lK4u$zcYxǸY72e(Wr.lJQ7b:2V3T $_91~_ wJ1KYюDnGj*mP'##JIu͵uY4gGkq)?)\._̡g&0G'? B-CJHb&\,؝NӍ/F`m/睩,t+,MkWg! @BZ`xzMbLRY?;;EA4 J3|f$[B{!m lA4FƖW!?W탿.|sh2]&? OzTM,̹ܜ(#ۡ>0xHEY:MFtV=#'T |c:y/,J>%;?m73RLBXj:xԂ I&z&׆*wP5wp6i9G*,  eFg^PRnb Vf?v϶r2<26RSJ2B=w!:(AP)H%>}+X27~y`NrP@w)1^VJřC7QVdU3 C9> stream xڍwTl?JH0atww0ƀ l8lt7HtAJKI4 H|S}s]q_slh¯waH~!4@EX$PJnAxB0Ы $S!1fzp@ $@Կ i*haOvuvAbnIIIv(CP0!]  7  %DzH =gyn>0xBGr wH.P? B@ <1^0G` 01п+=@04 pAH92y1 o 18da:O0PWL`*pww I+?U(t-{0 stU "s b@ PBR y.= B`L~pH !yCH$?HP0qH!NdP!-[po44125]Up_DC?eW HIӥ%Z n?c1& P | i_Qw>^nn\uC 6YW=#ZHf`nn"S8B`?TZ07( bzPB@0[v<>VA0K+``3b$¬#Aq` 8$)*H? q5 ,oj`{!L2?˄?l 8Wÿ6*7žf7:'#L ]A|WJ|EYDӥN[aT{˟vk/IiJvG|Tqy+nv6{#/I2bS7o+Eά׉^TN'ۄg/rțc!@#u"}V5v2/InHժpٴRg==ܓ[&873o=+]A˜&廦o|}LNZ+.~]3Ž9@4`Q{M zm&шW=UƼ@}wD(,M{Ph}}&z}^Q$+!tI`b>ްT` zz$%, { Z*lb5__i}}Y&_H$#aJ9ЪrgdVSe` (h Qz` CNk5%;>|:5idpy=&zD V>5fƤ(sJWj9~mcIyC,1z"F;Z(ИaăTvөݠ{Rl=VߨѶnHDE!\]Nΐ|<N0IP3c hP=wyfdfU@~ʗ9]N$ $Cj{PJ 6agྎŬ⼼-ӧyɍ ;iհ9[-$xHu@ M|Bs?|[pc/,`Cv(nšr2#[x}z'lI?7D:'oSYy L42 m~RzG% bd3]/ř s4b%oLtID w9ըA4B^ aEc82lw6>d9\/zoSݪ#wi-j,g)v$1)T+s k6OfZP) :ƽu1Arvl ]v$UG \]`X$ dԵpKZU7tqNve.l)g\^|]I7ϭcZ!ysuWNڑ[b|l>%Fo>SILLQk K[w:4qrIc=ppB;k`F x2͘O"e%$}cEͬ*&N|>äKCW#hшv*YK)T43Z{[$CWb}kb2.l(7 {vgpؾmk@ )\tsL}>eR]plf\aO'̛F1uP/;2ېƳ8rf\*^ s{<⤖"vn;΀}Ht`\;jǰTY5*8^ly1;|RؔcD:S_uRkSO&FoJaUk=B*k~!НG$,pW_zͱSoS/Jj댁msw .#L3,ʻ:ɵ5 ƙ/G|5Xbn'{9 n*2hw!dU~>JØ,yYT֖{|\pS#--Y^Wr>9e+լ] B IVC^[0iBv =hIu1IB 2}rFn3LflG3 a@RНQ0~wՊE/ޜ.~o tO^vj;1<~b[cMbkKtf;p _9_1Dtxx3~x7kjVkq9i:9Ycy+ϰ'NXʿفef>OZN`R[{_$*1rZY+1I1.vsaxLכ%+"%iKxzic>yYWRp%Ch}jLe; =}1P Ekex.&Ffګ>\Σl<,,9Dcs(XQV CLPءOw7?-j "YR>Ɉϕ5FF?,7Bj3U֮Nw,Cu jA  |*oS,cEӆ&e_o#mFԍU<*Mw  óɈ#4Rzk5kGk"I9{z K5k Qw^]s pMy֟ˬLߙgqfh1_;\sRc_b@Z~;_1cMd㋙R|ߞ(4^<+a^;aĬEyk٧֜6۲S٧R)gtb8f!dpќI^_Is 7\|9e!>[E0pRq;4o_n5oKf-H Z؜E{' Pࠃh^9rUx(}݇zR^`,V7%-Aɾ5fWkJykn02AHh^(u~ىfB~ɘҀMW^WcY"#d [cpU\I e fPsB?(#yo8G0ګnUBŬ5wsͬjG&^_0f$x}*j~l39S8󚑎oȀ(J>&J[MWqx7/{"sT+ssd<ǏqS=~pQpzɡr3!Nsxʹ[rAs#޵^poA{dӊ&jCЫhs r%KL~\xz;8]J\[9ʹೳ]'.bvoeS{2rY3jf?<^Hoh:Js/W6M^gN 5U:"'iez >$۽ SkA@;=̲=C7' 4eIEx7z<%W#ՇQIΥ]VBя#ס\)n\Ղzȿ-sJp,ۊ2B7t@a+uɰcRX h|" +S I^b/>:;753IbvMÔ^*U)]͹&}fPyp=7B^uA~]sBh./q5 2CL#P(5&t([*WHe\U^:ϕ-oVy7LH*B盔t dž+ۃGÓ[cOkxq9Ǿ/vu N&k>g]y!7* QTpW|@#d->`&şZ(F5Ju_-9K4I߇ VHۮ ?VRߺ,e44?$r+mw}XGa-xU2O*(℀k흁WDT /[[U߮6%'u9.|_(޻{"_arDaΚ%-d?Fb1weUĞ!>`=9T7\,nql\mMr|xpׇ<K Sn?$V)x$4RH.P-U\&xx~Fsêܠ_<@+gs/=DӆoY:ivUO "p ٍTWj7=RUh)5ZDvLTOٴԲﴮF\S,lE*Z}Q&} +r@>e-c- ա (tSZ~<<ؓUdll؞BRms8lgX4Q贇K=KwL_db~tzuSa+S ($=R}w3먥k*,ӍG=븺`TM mpq8g*T}0rM##*qeXwNgt_0":uoijCn 4) 9>3Xˮ=C4 匈7y]~Jcג&-)v_j `~3],e,GL_XfFpi{.$z^F9e9_? OY7r> stream xڍtT6t 2 Ctw "%RHJHKt%ߨ9y}kz{_ff疵Y`P$7O ' cf6#!?(à(L 2ӄAjnPeM B1\`{$*˿6vPLL;@XAVH3*^&DzxxX9#x`p\0B [vZVΠߍ1 ?>aPl"PnP[ Wh5ppy v9XAP{h+i =\+/C+rCQ (PvA"x`ȯyA]"V "xSA6[=V'(ljͅ vu*eAHr_QܲA!^.y|B| @ug+_U Z v?ciP& ?ݿ/z Z_Gk xG & 6} [kUVC}`dF8ׂAP ||Cm@[B-?S*Bm`_H`[yF>@ڂ<3!Q.T{~;<g[F͇‡B<`qQ%rd77xXJƃ{sDjy+vn9x%!v {elϊl'27>_Út[|-7[>Q|å6q5 rhBPcqu%#;V)] ݪVw]:cmT4Ŝk5Mň =$:9$}=zK#d?b{܀񞚉ڄthGnY7+iʶ5d d{SKÂyT\5*zY%ѹ!K0pQmSH5K;| !>}ՆJZX$z)-{c9+}z4/Y*p gUF͏sUV2MK@* NK 6E ᢓj*] $Dw^R}Jz`TY*maCZ1-G8Xd1&])lW ,{LVĠdDNCZ;Dm1^&9F1al}6^gcg{j`,@4s6;¡ ?txRQԒ:འ󱷪]`+tAec^ V4}IL&\;w :nY:zEScwTX$fϒ8wWK }y@HTm 47!Y'nXjfDN=X h3t2Nm9υ GO}) XMii! RHRv@eP7U&*ml;%)D܆! wFJ^]P7r(߸d{)ܧUuq $Ѡwhо4A"QiGS˞M=r&=~wYZUFl(_Nk\$NL #輝ooi4:ξuDVmhA-pq`܎?1{iģ@}C6ضgolJB"_ [sG_KOXSy&1X֤+XkƐ@K&Ok{=Qu=RRx[)L^wMz0W+N8&~bO/Er9Mg}2Vjne؎G.;q>^5ѭ9t+16^9zo*iS.H7=ٿ\7;3Z09)T(2T^QS-Qɹ;@F.XXh}p]Kn]Q!6Ń y͕>4QO߳qnȳ&a>#pS|;GM5K7ẗ xoD39]XO(6O-Zo \cB,Rɻ=^紃ox&&PntVJS).5i¼+|i!˃d͖[!7rKV+7 Wm˓"LV68mIsnv̞ٜqY]RuQ$UWkRآNO?MM׉͗bY~>oUE?3+lޝѐ?|ȉAHW:(}+2ŞE-逾$pjkoQߜ#pOulca8#6\ oLjB[Ɋ!ӷj{ kaTV8CIǝD.<#/~k'ŇtZ$v󾑵i#C+4КâϽ+tR^sNH^{]}튎 4 VKl@_7uMRX: -1/;s"aѠ3t-T*F4Ěʜ]7d7DH1_> P#R 7}VGGdNU-p9llx*>kGztf.ktBi3Ԫ$+6 =N.Q } :M?<6'FhrP+E i2}϶<ƴəI|=xK\=63;x 17.T{RX_iZLw?137900ծ}ﲵA=f,w-۔Iy*V\[6mPp00dǰ0}Q8(~i#~U-IHՌ}+4P_G1Pvs=M" xB?=Z?xR{Uhhej}MfF-^8퀑g179[HU)Fڳt6 Ǘ#S+Y8+x'g@iSU0dSSE `o0LF3 (Swޤz5vX Lbd %pL0+TPsԶnv:b%+.=kYMa+Ѩ;vȟJ:|918"4)I<쎱 ] [) OWUbᖅ09H|s~TP֖g)MP$xԔ/C\b~- aU_{RPqzlm+Sݪ iܽ2Gw&>!&L;Z#ph_odqDCIV^G=>p''+kZF H &+$ޙYbu{M{6L| G{78|4ҿ=RVYGaBqP%Y C}GYV\[ jmHyxfuv%''7bޙhS:3](FS u0 Y 9]fp&4^J'r#57n2y*^:!vikrLYh昙w;*Lk+ڶo}|Sڏ.wK/8MQzfƭ"܎s ǽ%*גZ<r>\ICÉyzh >v,en_nV ꈯy^EAzLe/mгE,}ߔV+ @9wu`AJV• 91|aP}"!% !8x;EZbTrNGCQrrnW ؆|o9DbxLD]Q#}])}f# Љ&}p >"g<% )lb5׶ E|qq/yMѻ?rƚgi?~%^v[VoKw^h јY)NQe"JsK8"qix†%žrІCYtW%ɠ]F0=!Ki9ݍ&?eX8;{ڐy(=Asbk'?5pR"8:HսøΎ AqJ]=no= solH{e1^W,fxauƻd_/1Ta>~`:gdsm-:a}S *7U~nB?BUu1+wseyEᢳAs4`@Id+އ7H:QQg;un˶_C$֣Ζj~{ʤG26h) ϒHp.}I ziuj4@UiV&0}/|վ*9 *uAESA+GiU7֢|Evw-RHeG<هreanN@+:]Gڪ+hمWn >jaN:[y;4dx[m[J`ltGk2Fm -edQG!4:뵘-h-]djP/<Ũ Siͺx8 AO ۤ|-ޜ-nm^m7ya8^QheZh1W3+ @u}哶Ti!l z+JEN4{=8$۶R*Y Hw76',Z03O%zjps$XLez94WE:Ļk*$ Ew/7ZȾ S]u;赫 ƫLَ{xpM{~?f6S-D!THj> zZ̞N`:5DPGmT8cb1͞npNu*lbqY/ E̬<7װ)iI)` vL47)P҃2?uPZejG͂`Q1v3MQvX-X'"]3ӳ^M8%kG1L~ ~zS endstream endobj 73 0 obj << /Length1 1856 /Length2 13350 /Length3 0 /Length 14511 /Filter /FlateDecode >> stream xڍT-, kNp@# Npn .]Z^UuvSu 1P W03123SPY)ԁ [0?x1ӛMM qX8yYx+z$n=?B'ef#$G8d2C B]N!Q1َ%P)-lkԾ9s9E_ Ӻfn̎E"-`<4S!NòC;f$AB ?柎ܨޕN>,-_SltNck{+)/vc~,yZ1ڳkѷ..5c.KESIn{j|9PT8,Y0^fn0tp`^Aib i룁a` 7#h7rU89QDζoΤH_Qqd>&N%zj=cmeno!D@e&+Ķ]6ʺ2.ƕn.v}V!jȇƀƪM_Ivt'̨"&/irfײ ' d!##OIl*:I Ȗ ݌8t^hɏxNjZ)"CfEk>\w6i Fq0>vs6o1K4o=x׷,D[ %]ۅғsT5T8, kVI!!ܾ%L{&f7/"=Q?~ɾYUi̬vPkR!س` ~(%-c:4ߚ\*yyCݿ<׺w۠S帛jYoi AeR:(wFaaNˠw38sw`?F#x$a3_zX.#q'4' d"ԡ ǘ"8 oxoR̔{-JO#z>*>Jb\'ç VCF"ɱDx>ASnJwThbMZ-,͑0҂d% RfwJB.*<349'}/zDw%@b9mkRMWP7Ee@|+qf6C9lalxK7a{& SJnj-F&up:.Io؆/Ok͈UmSl4 [ jv^625oLŖMy?c^ +t]^}^RXTĢE[Hկr!T{>wdxR4j=ҏ VuѽO7^|cF|uu2$;V.P)Y5~ E9z 9yocYyٽMdH赂+% W4̺R~X>٧7Y>5TS:iZؖ⍳fX<;1t٣)T9b퍞qX`LOC'BY::QY4pTyGϯ` i\sK (1U˜ce灇L~,#ŮuS_AR731cAQQaY[qzjATf.N,et)J@EѠFeRPR`_@+~pw¹-baKS+e(hI/\IݠW;K0JUyntS)qZuTxM/E΋ɗMz }c=pP^I -tQ*JS fi(6BOhٷ$㚔BmC+{g˄јKf1һG9%D쨌τ/qCco=yHUBOGI45Y!H\$*3c/kB<{V];Z;WFj#vh9"$?P Lx>p}z%=JR^*ӾY*ٱbޗɷL]'j7Axd$!xi3-ҋ-"uwh3&<&GҌAJ0LxkvVre-awyC= n8\ۚW_c,3.ɭqsk2R}.@ҧTpqQs%HB⦓krPLɨ39l85b;Z R蝎Hx Ĵ{?a7sWpa+U'!n:R"){>m7^[ }pq$|\7i rT-,OPr 4S}g0ѿojψWISCqE }Ⱦ/7 lq1tFZgҤtB~H=YPsiʯ Ӈ xZ?!a34"T]_ wX ~E/Y*"6J APƠ3wMsS{]Oە ɽ{zoc*06|ηWTf%k8r ~L7(hZjy|AfOBX o&QURko,ٙ[.V5pqa587eJЩw@o M'R <'yhƮ#Y3ICdj@#rnU(:"0Դ}2B!4neMSl~J_U]~uvdHpHEތmj]^ėI{@ZGdiwƂb@ӨfB= ‚/d\3ʖ1V"i;5f4"qTn_E?WnOEO d, ȐTWT3@tC ȏxk,+m<)n qsƈ=6/OսGlEv.'1A-9-H@>+\ &#jBtTG-C!3jDBh|h I~!W񍲺SrTȻR ^VKy 5!G8xCߐۺh0ˎ1 TXB~XLꝛIXFʫzLOT=w`8*EluNJ{laJI cl_vF=̱fmѫix H:;}1ދ+Bԝc%hw1#PXܞD16bj |JN/[:ak%hu^ZPJbSlGq?+uab.$eίwٰҫt}|vH(>o5ws~O$Glt슏ky5G;vۏVPH>БjsHݗ1/=}d1NW&j!ρ$EAl'//|_*NwHw;}iIz +y "j1|OWAT7.]2.q\8\](E`;M8–P)B+¬Un9)qMP3r嫡zu*"Mدq q5w=tt%ߋgԠn";BJ]TH.l^,T؇ZL"ǜ .IwQT9gJQq/wqQ@v{պg'X3 ilu?2qmOm`\&bn !v42j@CB| 273e[af\{`(9 "&3s޹?EJ)sWFٗx~i&gy@xR;Q-фF\fט+ Rѻt2 0ӣՕXpjۢ_>AW{Pvޮ)goU@> Ru$cZ{hO4,ƛ^ÕEM3a#?gD`[RrƜ3㶉XsTkV>(38 ,f7_&%vUB~$x`4:y2X`nʸ#߈m). (wjK,x%$1,E(*bLb¢i2~呫KĂiM&GǡT @ӓꖗUi"lƝdt#f $YԔCC(%oxß;eZb3f3E#nfH:?SxSivK.@'p{ldnCasZWN2SeD 1A3;&5dr qd6OGeg. yb1"AS[q\hf VUbLVىqOt?PH5VgӿRGPAk"RaxBGa[ymz]z6ٚR>I^3@i:h=ęMtW^pAR[Rzu&s^86boV VaOO1Fc'*iKjcFyVI%9.qfG$p.-Ur[L͚J>j:R }ϧuЪBB_g`jD+cOhdb>lKrY%ze4o;d&9'x6\yT6\+S?[~=-R΍DIL\Cb@d˴ؚ>i1*kF.F.2n;nY9 ޡi;VrX?-5%]Gr)}IXy-m!~HBS<3i^s:f:fE<l O;_FF:v3clmF$ CV[r_]+ E>> `4jRQ'@?d$Wb?}4z}WIظԓuw: 28d @EU:@tϒV%:C. (e;&8yN?m.* [)ƽMTujy qe#R3CW\5 rA+p I vO$yHE|Tt#l%2,ƾ2_w_CvWl"OJ5u`joUH#q5];#X;D8<;~q Sd>oqhYgBY[542##^lf~ׄX|Hɩ8%LM~M 4;I]sD5M&B{L~,<S߇VGEQ)b B6qIXmdaqL_}3lGΚWB8&ruec(;LmQ 35>/@i+dKij8o7 /5չw$ xeK90dh8  D ‹/ f3s:? 3EZgh1$.P~@!vql/\JЕuލ"%L#?hMJW@Zq^m -]HvVUѱMUdHF/%1W߭#SqP &C 8Bu;*6ߠ°^)1f볩/x.bdJkB3zElB\IJ?[ ;'˅bxhu|ZG|6=y|u,U^i1`C|nq)V ?N\,v[}/2Z][Qʪ3lthcA5\˷UA҃T0Tx//ůþEGi7tuZtzfU-HXI9/ܻ60ªC'˾7s^fH&)9ςezwE#Iͳlvm~gb^-]_ "rǢy;4\u0c 7<_ gM>_a&='YR)əKOzSj=tMeK gX*G]#+rrk^DidJF櫝hu7 fnzDۢ~!k\ QTO$38O1hC2{$E~-s:@ ˍUbȅcG TX6{3DD0Ƚj̱V*Q[jH7U ]䘃 4.&`K }EFƾUzWHr*ľTӓR&B80'|;) E&Y8kĺٙ]$9? C*G{ +pkn^v X3F2+ ׄ{- %QPU~Y,T꭬9N`+yxt,^tiA<t| ~W.(B90& ӲYV7i=inȆؗ&ɸ-OTPvǯNH Z>-*x|B%E=4lF>bɦ _qgrM]%+xxS{w@6c#AZ XDs-?Y:rIw^,Š!$,3JGFw_ɄCRf[tFjL{u@gȼaaT# HXyeP*w: ܼW`xABоhgs3]Mh |RyIϙdDv-X($v7ZzqZnS,:;8U?UI(s>%/L|T~ Px|0 ݊kp/ z2Ͷ0S܅qА7[P#G~ ?DJ]NV(ROZ_ndB%,Z:;\ +h,5Tm:NvZ5x_fpKGqUDy;(e2)ŜkcŸH5MNpb;=B) HBVO`K;ӣl{Ո|Ȟ_lDm mctԗM ~PbG޴q!f|^Sn p,7g5p9o' MUOpSp1]UyYZ|Ek?EԏEIo"y!or{>'XОw$J%=CVLA!=0ɓ*$I/ʈ=@>~<xpƓY2k婤:4 $C+~!.Rn')6`b }x4=@Ѷ tf}qIM=jg co16͐TD}![,6yƐA m>NQѽ(tc"\*52Wi\'aJM^1;d{jL>Btɇo1wC}`*~-ŀ5 OK(2ft. >U&U$8vlɎa/Sg-Wmcn49oߪs#?hd%W^ij*GYX%K*Su'!y9VJck/BK~!`#u+ ۡܚ^Zw(Qvތ|, JKm3hjifլܛ -? ~u&t}9pRxH;hhؿZezĠo .HJpd !S~CQ~, ͏w"|_}dss|RS0i.o>0kS-,eY|eݱWx;܊~5$Cm*OWi%s7YЃ?KVĕ/9x QĐ|U./$3$j&;'y;rAr5 UFT=5Az猃UW@mcݧ3 { _d ^к~~1Ir(`9ra%1Ǵzn$Vtp%Hk:$v\MrbAIC7Q)m?/R/>25Uuޠd/Y nA\dBWSMS^DVwM3J9(=pk?#WEwy7َF ,A 1iaaI0-QKpEjIpDk"x. GsNI ]5&Q#8RDëC8KOJ ٛ?y Ybh[s~^>unPG$*~+Ze.%5i2͹@ʹ#y=ߔp).e(r;(8Dm%dN׃-yi㤓{{ua2\^ZJQxd-|m-tg0pnPfn0-[5"JƿE /~K/'QI endstream endobj 75 0 obj << /Length1 1720 /Length2 11249 /Length3 0 /Length 12345 /Filter /FlateDecode >> stream xڍP[-LpwҸww5иww <;w ;3}ڧ QRe13J:302UXl̬j gk@G'-b@#7#@y;[5 `efW#/+ :S{8-#ڄEW:@219[mV41ڙU͍ٞƉ\r@S F6ZcYvڙ99ok -x[*-P,w=0?ٿ lJ6217ٚ@@3=w[-/F e[dwvbtYwm5:;4yw_ dkj S{&u[ P?1o&́fff.nt7`=/'o[>^v6> 3+` 2qAfe~ Oo 3O_G̤!+)#GOvڹ8Y V6ۃQ2\i[3;t_]?BZ vo#t=ff/gUB_F.l@D)m fC5<b^igi5S4#;fhr6[45d}X6c&Voӛ2rF迗53=k#GG#~C/4e[ E#s06XLAl& n¿7s&?[ + d0d~&? ?÷bYި8ߨ82o\o\_k_t/ۙYyư;ʎq#纯 V(9y~ZdleɋT ef{]I΅uOCǐʠۍ \֡$?ʻ sFDH\nn6D6Jvir+DBV2wGGH7YGiݜnq8ꀛ֠ONBd|;WRWgZSr6M9'9X3j[oXvjֻiv4Ǹ:[)1r1k~ 3 DS+kߗPQbv\n.4ȯ2 ڌ @-'A՟Q8Ff>j?wH`WWdX]3*hayg уAByj,};?meibzzA%P`r*v1E~bnI&a5"q5g`JX .l RgI?Kjm)(ׁ5o:QuPE<)|М8eS>=="\KFSAXͷT4ch,J&wdB:n"e(c3^^>۰@j_pbw/~hfM䙴bx{c?-G DD~vvڷsċX_k5 h9]2TM=cw[ʲd0Z`:p 9 W*3718[>/~腲i3N{Dt*h I Z~%"[Q?sDhD&|_L Km* 2F~* ʟ*@V)}NLA* RTWVIgP᧵9x;-qHs?h^V2SX`/?t'­'y}(ӣcsPi }w&& 3һxqnvyU@+YO;Kvf[.m R-W]+%}$|j!RSwmoݕ\"]~KMb^-VǑ~bF)P1 ^)7#  R 5Fh+Cp{*5U r%34Y3a`.tTpkܯ(Y W~iEj̕܍ nƝ>hLSdNBF=?uK7ORFZ:c' PP]o?" RRSִ\it^ doz+^tW"XOyXvM{0?X%wcr qRxA_ܮ</VMVft:l<5᰾/(x>$XNio˦^9^w;fSI0|=Bu?ĹD,}'%ls=cmɥQ)q{y:׸w|y-(ժ sbkt2w2?F: 4d}9NM 碗/ص6SX"8MpZ+͝w } &B\ :;4uw(}35e6a"XgOD~ncwv/<ڌAnij[_}ÎdOQm* =eDS 'xPX3ut I<BA9jJpcڦðGD\">Q}LB2fdP|Kio᫷Rlʟg&fӲ,1[fJ6-\cksWxYk[Vjx>Y]n4eamGLkRH6)* ]2&/?C7>nYI?$ >S5Djfqa#-qeer2i|Jtb稙Qzul8֘M?~Y#ՃqH붸\o~M à@$q s#T,ul&E?"TZW7Tp:/2FE#h[ERpE-z0;Χy}JaZ.E‚K}lJ/;圭>ׁK.T~rۀ ,Bփ"uXڂy+)q۝ 2k~6]'ťL8q)O&>jZoSp~60!ڲNiV.Z:[N-7;7=#&D<_$ OY~bQ!9no 2 ʖ;{fzп,qz*Ms-0}*p].{`* H+l[P3Wvx29Vu 5m B!әˇ*fIyMIb )Iu,ZwzZi4X81ғucˁ-m.5H#S/Jdf4֜~Ŧs8k[:tQ_3MCh%k4ISw? xnFh~lw>4*t&N'P$yЗ[skQo;5**_$ o 3T X.W/vq^i-!`{7K3Wo:9b8+8]Hgw;_гKyayppx5ӒF؀i|лK$<2u MPγQ4 ؀}!ƹm!Dxݥh~͌ڽf5Qsi= 3z gW!Fϱi~}_w/lXσhdfbm KÛj/7(%T,F`tf.6ey4RZ;JmGAkvVjFYU^q${2}k$Idpzx+Sqs&㽧[[ ǚWx-k&~!z-[aWn˗z /M6P\=w+mqյ] U7wz  LSpX,imlg$eCbʬO,+N,jh{_*^ۤWbz^v]kDتq Ďz%/Y_@::S| ~lǎ:B%2V%0usvZVƑs͗q,_'~7>7iM=<9mb]j94! LZ5waA+} 5ZQу1Pcɤ'Y9FUN\v]R^_goQMkTAy=SSu0(akM.c8`. BQD(1Ĺ6~OĘ?]-Ǩ}t|ٻA0! ıq%D-|-n.є[fF /@^k݊3/d9 q@:*"nq~G*zDB߅v:ir@u\Z.M=)LR!ј}K/Xx":=2,fNH„ni<:@A.bip(37 ~<$IdHy<2|ۗ\"y-R]-dnUȻڟE|灌un"9, 0lsMf6>^Yt{JA_ksv󚚏9~ qr Ynj1>g5xw]U }OMz< mP ׎.f} Z,ۂ)]`Uabk/e;fl\*h強l^029zs'cjt Yt4"a G]3MSĬi0u gXvHHpbA"vّ22l`ӿvv,dk_"ՉEXB*Z B3_t{X:};)T3Kȭm$"ʪ]զk&_O;VP]ؖA9+=(JX6 pNG{;iO FqcB+-EjWGBޮ$kRIQd>ѝg^N+y%#Ayywn[̇y 4Dgդʮop~% ”k$K+Nũ!OG`qa6` !ZB/#?`rTMvX{꺽<O%2~{1F$䲂E;)f4]bD>,M̨*J[q9j%&|u ԓ:gA4) fd NNtr!Lj呩,Q$R@^:vh4aie2W <R:}aI%8ƃjkEڄr[pB.IĊS+re{lڳ,Qj * 8bJbQǎ$xr]c$dt~\[)䉟qϥm/3#H;LSվRn+hEӑsrq.v2p}kXՌ5MA []6j\1 > M&NRL/R0 Z*Ql&KVja[SHghlTl1xU6 qutx>ǩB@Ǒc:\ҸY만f$PrfIz眩E^ 'pfLCrb:ܑ #uY+Y5A_6_mqfXU/ ` 3$[3`庅fw3=e3ՁHxDuȮJ`VA2I-'K{~3͉̏ﺣiH)1gMK=PťCE<" a, }K, J3݁l %da?(-1VaNS?,B)"65ٓզA[pφ"M]3g$k!<., F)6-xԒ?6lh->ڕ! Plo(Z vVi7x|m!muW [) 뼆g%Q<`$M\ļ4Dn*"ђy" ~3Gx9&7%aӎ-5-ϸ0 p$T+v:MpXb}%+ɦUeM%Y`jp1VԳ Q+wR̺p3k܍WF,>cQ(V|Jhk u%?<ڬ!r7@+F(;@~lI$0U %V/iJbL\$_9%wu]^m}VZ)u'~rl^'Pe;3i%Z?cjҊ2%5zȞ&Q@{&%֥z+rOV j8ћ?ꙢT TֈNXrY~0ѬĆ]X+ FPIg<2kU5Vb֚FT4h 9Cb6b$L17at$ 6݊ETPb*ӲGkqCQ_ ڃ%nAn1qܾ#TPIGgw^+8MU\mȵ9blB숙vJrXWn'Z2uH od?Xߡ-UK__T|qH|0WK_Ց!^=IIj!ɵ$QjA%ROΜ(>8"x vWM|a {(?8{PnG</"-V q^0>B;{@+yH|r g:WtW1N6,u+p³`z"HS`Y+ @@fLgp</T{SbCI%9QFL%,٣i@0oQ zĉ& 96gلw,[_^!y=?z&>W뫷fܨ뎞CƏ\cfi`T ~GgAApc i ÿJT1I7,*7tE@RaMP"ԟNSfvc0cqM}qTGഥH {ڦ8"8!/P jk7Mp%rEvZx0P:%3Yq6[sx%B:-t? v7vY8GW=ȤTFsGgNLdXCs,7ֈ|řR15~ $'*¯.ZVnFRLe:1hḾIA $pyHsg'F#x<\7:2i&ømSqF˝3\%]ɧd-&J-JAj=k27^a/A+ pS:lT􉍂A{pxtrMDCA޲o<|//}~-í݅>/NNȰ ߴͤ%b) 8 tl+}`M,(#;KIÌc]%&GQz~:i?yǺ2ut{=ylbH"eU 5(_FI`<򂟔bKaLu?'5JqӊR/-:C(o¸U=)|,\i&U6EhNsfXNk|u?BT7&(Rt|0: (X:d8AN3oD7ǞsY$W* \}RW+oeIKלFPg7dAxXu?Ums ]ޥ|k`"IRyzy 1z8DzI9V: )CM>9^u`j{Zǟ".쬯?frlC;G4ֵ(UkYm!~ AfHξF0 a\ fE1VOJr1 'i3pkUi s4$J2Rpi qF !Ѫ7<Tt~uOBMUf5]ȱtJ[zf}Y 6<-6rS^6'}Ql`Tu ]:!fllOAҫ`2]O 2~Z qh4{i ^%BZޝsAM,qG1vBoO@|>vAKZRSuc$xu%OeKϝɗ (Ch"dM(.v+bug`3 endstream endobj 77 0 obj << /Length1 1554 /Length2 9440 /Length3 0 /Length 10465 /Filter /FlateDecode >> stream xڍT6Nww CwwtwJ 1)%HHJ4H4Hҝ[oγgfz]ny{H sI ||<||X̆`+_v,fc' H ?mD-( HJEzJm-:a1+@?;'BGQ¹D[W1jkHS-@Y^``w8v#4ǬW p }.$_ w݆;RSh @/Љ~?Nܡ6@A`V{zo;#f_=g|{e0{(??W̫akn&wv>} p BEѵ]?b P_>ӿJ[l;siC G||w"e/W?~oƣrS}RM@^54C/' Sup_n{\.E@qc*?*Q) y@ _ka ph(Oý9& dC{[/LAD0?v^sz+jhOŔ[`zB]+:WLK`KFbHvФTnhs&sGE'X\,: RD|f[jv5&رد';W}KkԻ2otPiL7(nްFO%ci`k8eN{៘.,ϼ'%' {P2lǓa,nb%AMIȾ|jY`^fveھ+(@wdwSjT?isVRY%ni"Pμ?0"Po,*JTĘHn8>2H5I_N0o)H d}Pp<]ʂii9[+Έ&wJczы;qn_2afYPoV,sQ*Qh,iF‘Z]-:\{58C3c!"@ik&w??\@BAÛ,=ySޣ*ٴODD%e B <#1 9O, yGռ7uo,mcG.<2GX:z*-䄬Yy~]=rE]Zc%E1aQXh7B{nҙU̗K{ N\nQE*+:RҪkXBL1^)D+LAsy9},+2.|۸uWwiX^_i -MK("}??C Q%^jF͢θkR@1 Y ;X'4Ӎ"fvCIXHDA8ւï4W|ky@["J?#tfK.UڔSgM|6HC' xlYمIJw$,>97KTiOiWx8!~;V~Re+ݠt{ZwdT׋0?oL@6TcKs,AAOӭ̾JJAH!= >m`Y8!6L"Ͷ /ҌBlM۬:" &$oMv ESd;Iؐ ٙt E\$*r5$ !H.3>݊؂sINz"iFư(,UqAyqEy 鵽 XxV^ X }Z%"J7e$Ҫ+Jpe3,"b'@ Ǟ \MfUX6.8J 4PNVuS~l˿vOG/E+, ΞzV=kϘײv1ݒm𵤍7_oBd-35ݱMv&Pk4m"V\0*q8JSW:c&(Dܼ ey)Ceӻ` CO'T<{˜fsO47:.IĒ$1374/\hx.]Uu&].dMgе\\LUO_bZ*·J䧬d 䞂E #և@7J15ixhR.{S tJB+d^spo8FW;<%%MF ~XG`bF(%jKм~2[خg,YM  nAI:K6\\tZq%~D׍ )qN|땶~gD 3zkO;^üt\^ıQ3F{?Zi-7_pZm!t+}TX )L_M]t {OOc˘ ESPM1-ۍ=r߀\VhBTcXm I]Zz4$;c:II෥QK#gSx]; 4i0&8F$\wA6/g;*.ۍ؉8TU)9 kLܽon=oo?)`öją7=[}Հt;>aVtqpIM:06Do y](˞b87sHPK.#:!E4,kK#ڜ]$.&IqB%o< oXE8vPX Ny%~|6\?q=y11.>e11C:qeecӒs 7']#" |hf8R\+ONyڸl$w`Ϲ0Y1(LGHA3}JedsXڸHA/z@Z kU7 qv턴lJCBܯ ygXL Wr #%}ʰ/J),:UJ6@^qIJn\0 ^cǮ.Xe1LL&nǼh9)o"ձLW-62fq`,c͊^GIo W(4 6!OIyPKJ`2,"EẂYFIE`A T~mCWۓ8s5 q3Ή!GSЬ+gϖ%rP3,o;QɇV*֌#$r RmsՖ{>`=EkZ9.2j"uUͮ!oɲ!8CLe5CNq/D#MuEWN]Ap~!u(Z+)oՁ>SA[%<,{_a\6;'@۹i~-u6b4{5}t5.-J1/_`z}z; ^h9~ p_Bȵ(OHmTy"ϼIJH%k3Ǖc*g?nO#V*V|%P׽x&r*F$X6p>MC}jq rAߚ4p{;I)Qp[řugcer/<qEa["yɆsj@CP g_L~dxU"j,Y#̲':AHFDrZY8yold[sRw9_H7,(qHW;>|'\V # p;H}G\S>Rc;LKb%Wȉ6Q"* #; 퀧d8~<㛝L$ dOtG.0v%]z=Eإ+)`#Acπ톺xI',8y^#*5QRVs{23NSt]Ob&& p3[Hᤚ4ט7XW"&wS5y #U~;iIq/yGHiqҽsQ2Ca|*lHd43m*&>OO/n bj>f5mF oNW_iSRt-5 gDpIg4y d]x fi ' *} ,QJV]6rJ-wg;`D E~2H%higYm āҧM^{5Tst|lRsICz^;M."@G J}Z2y3(΄עGbăv/ 5 As");ٰDH!(:ŇqiS1Qb./( Q>mc5D>UAUogl5$c/9,x L4n9P`ן:ASa~8z@cZ[z+U h ʜ!7=O-Bǣ0*)@+H7y!V^2 ĕA}SwCE?5*>-Yu1?2a]=W`u4݊x|^56To 6Nї_9@:d+oW>2D]D@Rntp3WF%mByDABƁ4䪯6uKoг u^*`+Ddk().t/920CRub0K-ޡJ.ܜބ>OuŞ7d>:(\ʦ@? QѮ f$MėjWӤٯ D㌸۹f.p+=679$>=,H]D\b@M5^P<-ouZ1w9$Fv Ԯr;wQ[T,n4yѐBQ4^eN$&/aDtn=sc-BnҁZSi%NtPCmg)hpKndPrѠ8?C*zZ0D| rF{Y~G&[(72J9xvx6-}+!\Q#cOIekwv|-Dui~H^D$Ǿ^IZ6[NZ^#ϧF{ô+7T=nL2ADl><,HJ]՚>Vn;O,-*~G^=[Nwf¸[鱃rK)1Ƌ+(_TvyhZ[_$ӹCFE(ٽQbߡA{J8xއD\nNǘ*['q~K=kx E@=6"'(Bp|3{1y.mTM)AcXZ8r qf`Ɓ ՜' YȽzY;2Fv ?bkCZׯ6BO4{ V1U}"nc,0fﱊQE(8q cr\oZÇ8zJuҽyql Xwzgݛ@Aq2lj/k"9z]Cieb茚+"Jt?1c+WjY%AnrR)V| F*e}Y8, !1)U ƻ^`dnbWf,ŨVqzN-nO 4- c:7J G M#X˫'2AgE\&/~ ѻ.u>3~n3=o_RRO>ɺL3±bjT Eix߈6ꫠ"7wK (L#q%6{<,Ǹ+0(.ߏ-j9 5(]>ܷ;fu_[,t\Яw~y!s,xQFEbi'c&S>gtӛ!䫣< ܙCBs#H8%y@\³gR;| qdA@A| _lrqanxF.jLò_41;ʤvjbN5nqş ;V 3-asPK04a-fxW?~KAn3 1vxnU Ddmtw}}YMmǴړԐ #Ė!c>#]WJqKF@۾(vj9h\ %NdȨӤ<|ٺ}: 7bO}lT^`H~A%fNK bb 6/UrA̡G3VQ,ء@r2q0Ժ,q,XOx uIXOeMj!S28+,AVxNj{,rY0滢晒 .jLx @’WUo!@U<05QYx]ny`ƣ] !&\e&Vߟl< fz#ҋX;17~Y"ΤߴʉȊ!IRϐ""(a6Q>qK**`Za2[ې0by1]_gP!+{?V{mvoα'tn`sS7o$ i;kݦhIoY]W2,.tjc'/}C=aa<#E>I6z+*~\U } ^K LWlqg]G1lM! n|VA/cQH6(_[xEH{ACD:>YQӄL̠ڋEhH/enէ/QW px?-F ($onm+g wEg4BimY.2y :CGaBm6z0 cMX!4k% }RV(l:6[{naR1J{?w_r6^Rt67v#ՠHװ疼27Sp spmwp&{޾[=-?|C+[:YԌmʘK.(dld 78"RqwećR _l]R> stream xڌPb ָ[Ӎ; .5Kpwww%H 8\fΜ9{UUkuAE$f6JA.Ll̬ Euu6V++3++;"rD*M5/ '˛LP |pqظxYY쬬|5;$Mܬ̀`Jdmift6>>?b@'k3@ h6xOZA+~wwwf{gf0# t: P2U3"@? 5&6\\A@'[v@ 5wd l`Y,eifF C;g𛿉Mb&oU35R s =?Ik'[=Y-/[Q('͛%:fV,$PtdCV`V pqrz[ `nm0ZZ&Z~l?~da`?E^NVNNᯒV=L&vQTLb/O9o]/a6o,%>+/#_FҮvvic7mo]]n@v k*ͭ]V@v7YhbbfnGǝY*`g?^+ѽo@f`?`dI\\ok4zfV/H,x, ^?"7aH,2(#^v?hLFloLͬߺcg[m@ζQ5:ۙ8[+[nS'3_bտk7zK`{<8Xovv&Nxk_?9@`1|KO=o<Yɬ:j/V?}ckn+-4Wʷ׌/V?B8}ŀlIo sxr5oϋB _Lޤ%p ߙr8Y"7P~{X\PY\ݐo|ooP8aݹx }YxP-T6Pc]d?0XVd)}X2ՌkNQ,ݥe򔛋 CnÜb<W`ntNoONyY 5K>:b+]vdRxL9yxu KtEE+HJCC*HoGk3@!Xxy#w\7Wݝ.qH,.NjZcOvH| Dgڤ 'Co{r1(,jNO#`u|jnJ"PaYԭ,8* H%(ΉCEPmN%-PlGo/aŠ/u\wGwsc*6f(@ZR/n"auAogfWߌ͢ dt,i: n=vdNiþy@[  >V oVnn',UV>SwŪb0#v ר"ׇI.߯O"\]H"-'R##,%Jv:D&K6. f@GFjɵ=kq5SiǎhNV3Hٴ W3wz.ӳ#ɫQ"Viͦ/+P情ȟ3s.KbJ}4fKO,`˱$ \Szs*22&~b l,iCuj-5AG961^cmZK [Tlz(L?A_~H2פWEpdQPlݹ,E9];<^MNf؈›.~DJyдݞpI}tt,.a}qgC~?7͖3͌lCX-];L?,z,aKoaHz"VU5LPư뙏Z6Ȑ)݉h|-1#t(ċL2SznH? Z8WCjORm+:[3$Is4iH4h;s(4R[*JGj2쪨["L 4ߏn>I2;Z!̾z 4)+q_Q0Ql\YyWgrԝl'yݹ?`T}6R4p_ˑ`{[QA) \~!l/z\9H6hט1sۗc{q7 :!lV\wyxFLE ˙;uD*c3"`Z|~f3 y.&,yN#.؜֧~b;.1uGd#ށm%%Эn;8G EDysh(f8?dN. X"Z_0<mig]bcrVØ/U&&fj1*[["Ӳ2M_A\B':g$+B|J𿆸ITEvaj6v>)ux K1e3LOVNUya|46a~E1n%:kaΐ pZ?KO+e^$T"GIƵ >K(2^X2di:u)W Җ' x bbub y660n5騰0lG8O _N&Wj6' W>yoۮq|[` mcTX>|K"ڗ̮2ROZx p|Ov>&É(x4̎?M5•C4AaЦ&٢6_JV^5אKS\a^W8y0"=ehgz_67QJPz#+FwPʽF>f/D^AMb[&@}BS/8I#p:ݟf.Y`Did#p Х/qTX +sBWU #ndůQ9 6<̎\UȮV9hDa wMų&x}־Lem "#a6uW,ѥ'G]*mf<}QcW=0B҆kا< N '/SWi9ҕHu:mR:\=`_v.U\L+KMճWRGr,֜b@iT l*$AK;8.*)KSsDѰ#8YǛ5q[Mu˽OϹ?}i8풦E﫺6[x2Xxy2;M{Xv>`|؜Y ^뾭WZK˛ԴpVo0b5h‹pWn,E=9Rr$%Hl'Z*.mI]63ey1s˺(TxlxW@կkUp3@@bZ4$E'?0[Ҡulk$1i.B_:Gf^OzBNcXb܂醓mTTRpȇ.-]iYуIs`G+J,~g<*87zrEqXT>%9w\V hL { $8=U ^odxCh_>BwC2G?2U'ϝ4WM&H0i`v['@sS2ްMpק.n` /IC$BR#rurokj#7'My!_,`ˬ6-Y: հ~Rr;/ 5(&J&NK e)=nU\uP'\@~I U&3!kWq/*N 2e}*zkB7]p]wcmhev7iے`5nT `Ϟ.2HxquKTU_\\uɰ)( y좶 "#D\v:ET͒]Ꜹ/c)jKvJ?cMlFBK;\X79 Y6?}sCCPkr)LC9Mej!vi+妖N[wzTK枊?Kmao}_1<^ϖ΃gɱDJl&M_x=Q!S&gύ_tg"h q<5z O83_`فwD3]wz3$K Y[ڭA>bq^:ՈdGS?lgbSeua(]dn IUr勐gi ,| Eoq$EQ8k(UL( G8SӇxcnS1i 畹YiI/;JHZ!q.y- )od^=}eN2FEmJNٖG"툱a^CߐL6,!7L _)fQM(~C[M d[2-nў|$lE?+rj#rMQ nW+\R6[7;JJ3VGď3N]هauin^AKX㒡q`mjH&M r/.P.d_⾄u^YrtBI5oPBȏzdLEl\ rL/ r?!B)21?NLQl4oǀd(Y(N긦@7VY*r{D%uA9!~x?dz矖N's*Rw-mG xDSM”X`'w٭K\hYEw}$6! LwoP%"# q< 1.94`$^EbU.hG?uBJGs=&~ziA-XJΑ/ AxfƠ>P훧ʓyԜ t F׌Y!_rձ68ԅ:8mq[.h(2\ҟCx6#?Σ*$UYo Y7HjCxADSCTuc># PP sgx)˺asawT@ 8̺iwx^?)%Gnיqǁ09VoFþGi,je &FГ IAϱJ۰`1Ddh-Q}@,Da8#kY"םK0١grp2_\._6lU|'ypyU2L^bq 0EBdt=E$ϫoxh3 WE#y ]Y {L55ǜEp!E[0My z4'9>7˵OSn%yP˯f-&$R&UgxWOY좶v@cr i]G8$(4UnfEn'r)&<5|1+ڻ 8N| yL*Ϣt6@ rG-imekyNsJ{ZO1)a=U12=MAs/*uhI>n|6ٞ]Tb0L*۳ Aܹ+j־R7krdRDqF u|Ke;D}h(~~]|(ϷՎ+rW?iOLU9 \V5#P:"`ELQ伲 6ǧs/ͽԥ܋pl7ZCǶ&YఛGU%4L!~uyg;rGKP-}G< uD 0ҲICH}= k(Fe8j>-%= @=DaseVz-ă Q/b+u1kiQ;f6?VVk|1Yu; sY[B ٛ@:֏}1-従SS,Rފ俣tuGஞ5F;zpO:ZLᮊ>dHY: *FM<ٜlFweWMQ0Y7\%PNQxN/1g,.4ONQwTwn9|q& x.oGe/PcWR>ɬ&o~6#D,]mK1._Q-Æ0. /4rR'tVetv SMBmM)j pPNAf;6Q@rB1"OpHMcm9pq` GBf!בqI%H 国=(vC2&ʚ(z ,֮ 1}즬v9(.GhKze.y8-n"1ԇɛw޼wˎni<(_X3!QR~N҉nԅ銈H p0] _*%$a0}4Q_ ˇ]ͮo=ɫ.ˍVu'.AogYҵ򱡌>d<8$Tx/%B,c`v8@j}I-A$h)}נ,NuhPkI+d]*si[az[cYaF11"<%&a%nX򪜓agYד4YHh}-zs keAؔRB!!jn)TJ>{[7&޺v=R^=jנ% R@ZmYp$$$aMD>v&;Ψ?T` rEˆx4ڛu|AђȸQ* f}Uiw]} Nƪ0YOL"ř+Jm#ko뻎>fψAeSà &'~z1/I1q-f8 MNfLLOcB K¨oX3=uC{I.~ ~MmZUBl-xRDi%>ڙ ǫd= ;[T8H7L}EaZPm2)lʠP[# ~y&3s k(+:џV={!^c x= '`Ŭ$<G 3G;1B$/9M܌/=E3OD8JzdQR^WN(Ų0m <@'|%v<׽ۦs8:tp\!_`xX A-.fڴw.^rO`tZi`'َͩҏ(z5VLs)d 'eyS`VINDYȧ,nbh FL5xugj@cFER%"G%'݅WW.Owy|2% pޝ+Cq'tk*ȤU*8:K".]{<T~s@"Qé$D M51^IVQYsVNH Ԅ;/ja! fc#='$mK^45 ʲh ]wۡJB}? {r=_#gP-(VD 6(W $(\[z`vT$o,f]"K%Cl I|C# ¤(&-FiCܪ)U)6:~̲[ _c;R / OxrdvӕSwtCmA#h3Dc8LC5Epg.:+֎E`vY0P]X fsQnbh 1 wwgX׽xvDb+~cZB:ub̟, ^>}&E.xv}t+%T M6dq=Ug9ap#MWaMEQ^v"X]+ݗ[:L&Z%U١DJaɘt2cOyQzdwZXoUDhR&I1OrA /d-"Q3Sۤp/;Z.W9&>y&:Gs9bYQoWR:a9 diI$H9 $e"!\|>&M !Ev 籸Ep`a@,4 [f_5_L̮@!3͝Iamh+}+aZDc#v8=GۅM_^^9\৹į؝Xs5{/u<" a!e-*&H=emFA|b3mA$4r1͕KD.P8]a]wckrWΘC+dX"ej#Kh}T3}0IEDWgQ<=:|_Ρ,"r 5{T&9qcPCs9Qt,g;~JLA6C+Keh>IE.m<@.}o4t@! f1/nު,^ J+z*-N]s,7Z(&EL8Iع솛l (1t^TwC.k$nKOv!I)Ǥ\4,@%tQp y/:fBA8͟2> :mR2k}JdT :)%Q~^үFk) Ii S[{6 owKЩpTI#*ٰKJ kdrmmd%wM(TxVw@{&Y#l9v b]nzm)mh1ӄ.cvX4q[riLjyq&⠾"ĂZhI0PK熅(z8Og TQx ؇~,AsSR)܋C觶w>lDNp)4n'w;K?&򥝦Fy2hk5vD6H6xMmK; MެlNEDżU.f0H 34@Hz EPzi 0{ʲ;5EoΥuĐ?ߜ*n力$~SB?ҊQm>K7lt;-`Ou '>y(ȨExSa^a w*VF.C3a#=o9>}ST@7ukI4Qٽ˨bMM^͈Yݗ̓B%B5[hsBggzJKb2=PX&' ]g@"=ChFShr hk]O׹6~]UXYɗbPҹ`rFDj ՠw& 6!DRb~Ե?V M@F"=~; 4T;ty]?Xhzf@2 oӫrYl)6<**PDpD}7ilyݹ=VۍdCba@ئ^LjkO Ra]D}Yh* zo܃࣌U甸j 7DL"U`igx8!<Ժ\|Y,v}wl4o"ՉP&Olb䣫dY&Ss̀4z$wGH6&yHF1bX רb^L}Mxu?]Ў7\A>ZLq9&lb` ٦hnc:W gs遵TȄ{vj{uCQs_ 3$gqtb15ZQی&̔C}/?gqP.as!Omt~JWF|9uoh4{̾zfRzp~zSY 52"j{Yʸv9K,FG=mp. Q.ݳX|Z0>'[BI1Z!C .K< wId):(|=YiC0\=lLjMaѝE N"<g?`mYkMђDCs#hY$C~>q,:њ-_3]1 1_韲&TP n(&ܐ}-{=x0+1,X#S*^xcjFό=<,cvYjjc}66нG?^z/j EΝ2}PZL3h(;)+oCc{BҘEqˆJlm S&[Ec]J1Dg\7G+I]@|)=H5vw~%:<|(%ڊhZ*^R>y)-нmңuJ+}v̫D!F{6Ux|2uC6X#';e:ڀaCOC2C+b~r-(v6nFibfTr)Ur%R jbF^W4,puT D4RO& BMaaU RW*$$CU("wxum{c4||+ >y? .)~4bV6,I; ڑlک>!<i^>xԤNe6 Θ3.Jmbcs 2)|DBq5B}xEƍ;y4X GZ;/%;ƿw{z&"lof8brWlcaթz͘P]sۀO٭ilK?20lt&k!EQ-=ENǯْ endstream endobj 81 0 obj << /Length1 1816 /Length2 10396 /Length3 0 /Length 11546 /Filter /FlateDecode >> stream xڍTj6LJ7C*=tKw4 1C %!! ݍ4Hw7!-]9=>k}ߚfw׾4Y-f (H*ki @.6 ^ cF99 H:LaO6)SO (8|@ "I e (3:$ le {J?|,ۃ)d 5`╰5 fjuzpì g+a=Z`PKd O'\  'Sr@7ll@`_M͡0 ` Te`0)7tlgjDrS:s6w;ٜv[di I=sF] d4voux, MX8kC. y(O&?6+ 8 Gܚwx-_οOx9@OM|t/gSWO#t0Y!?Aw Og$/ (eגQTb}Pw+/ w5S?EXB4j0; I ? ?}q? #&]_W?nS{?'ɺ }Z L@be2`wfn06k^1;0u~S@=핹ӻǿ\s:9zdxZD _ A#|P'`mإ `)9]_$4fvOEO*g)7rtyRS?VܧKCI<?'?SF*98*p =)jr:B'Ӯq?Eq? f3ΧOzK.NNO_ ;\(ئ&J܍u4dFVNm.( kNW Cݸ˛ү.jQB[c5&[&?Q`~p ElPvtV%quW4nn[}Wd5J;m@ }Y, 3+*;4~#B,3QW:gYϕ2-NNR:R} KI/Dy5L #+T芽Uvl3@.3e7z(O)JZ6G@sdafU. & +ෙkBuM Y~К|vS&'l#]!P>T`EFףObI=KIB?;׏i~&̮\nfR(].vmGi{cDY(le-y7WɆ;XI>IE-D4WTS:XSTQ2 F hmOӘ6#M;Grv/Q>QRCH^N8գ'J32lw`aj}"%cfQNt&2[ENW[CVn %.&5F'}!L:HVdB2Vⱥ;lFM+!$cAq+*fٟx|w<\`j=hV͚V:Mc Rg\yt;O +J[$_Q~ZH..\;nHႾ1e2.+F$p"L ln̏ɏ8pmŝ N{[MhxPIszEboc0xĜ[ɠOը4~Dzع7EQW0`T9CwZ-]HU j;Hd> u b508!\$E' xUO,,gX89=fuBʒG'O䃏߉ `הß^qۧKCYt:ZYn/&ɴV HѠ~i(O0~f1rNffr4)&fBA!\CU:%B Kt_&UH-¨[P[Ab8jH;қgKG}?n ?\f5ն0%ǨVXBX">S&%a" uKܹ{%P Yn[h"z @FqƱr&< k'-`.(϶BVC R #eHun/DAG,kP5o68pF<6&ZRhdV ~o WYaa`sz6c`#Pi5Ȗ2}޼-CL_Q9χW$ݍnmx Ϯuf(Mq |JAʇ;0ig(Iy~9E( ^ˆPHD`;'kHe{`pCX Jq 9kY@~tL,?_@?4y! *:&'C zD/Pؕ6,|nyG` ;T=cTzvo(U/'d9KPm #/A97՗ĠUنogKzw2J /(Uw*^fGDa{NK~ٜWJ R '& a%og53˟e5rd.F²K>p~*)򌿯)|{(DkF8үytGG'- yܝ V*mݺmɪ)ӈ^y}-A&2qזE&ֺ9OplQQu|ƀ ܳζ8`Ňa DvTo·;7[#>"Bjr|(x:upmrt f2'Z 7/ӭ%ZF@a`ϤG"v'\mb]I_"¦ ⰼ>ܢ?U6//]ة[= ̿ͷ/ SVY*} H?O67JUypKC-ƾM\/}MHQ6RJ6c_wmc{]m}'O2ɷ( DmK]@("/M,*'+N1x!k_Ukr/#ML&69Dٯ]&Mk-@*:_P8͋oӣ?fUgϚT| +Yv&??|Ǽ^Iһ*UJ-2N4$^38ݣ6pu"C'reH5z!t߇K-ڏɯ<->5=؀T!ZT>гDt͙L;cѭpՍv8z'^4uGB974u sMո dKbq{9>HL= ugǓ~}!sYi1No)QIl<@"*'aݸR4L$gJ+C,Iy3VICjR? ToJݩK!7JuWt+!S o vb_v)\W̭YˣouϊGxQ@6ut:n7*6C鿔r]WKT\y:F~eLg_E;mڵ~9["\Kd/tPōgzn|6 I Ckdf|HNoWzoͿNU$ 1yK|,5] : cWGjc?$3 ݋@U3x{Լ%lJ GJ))mb!kňU22F6&2cG #nqƉzIO`avJ1b0ukQ 'fqʀ##y5+tRDԂC$*:={9a}?g_%ѹѵ6~.Gᗏ-n<{QjHoV`L'Jۨ2X Ti_;jT9EjQzj2jmXډC0HDΡy"yNgpC3JxIG]Ȣ3b\Ru^'%p3%/ 8&=+aHV 1ZbSo~S4f@:!c\FE/9m "!Y&Ӭ<~;f Upb2u&Kd/Z@j1\~u=j*&͚.Dt,' JW3[ "n8:3hv)aZi2H拫mhKఽ(Eofqj̎=DdS(L (B9聆݇gt9'" snCFu+ ݯN^MxeZN>čxn~uda;MqĞe9J#K246tJItyHnwzj]])(f߭hQTB>PR]}\L9HQu+;ܰtz#,9V')1QQ\z r71GyAɘx9H!/j&7T *]~ga)d+Jb6xn<\L*9_-zJ|k 0JR- -jxO 䊏-֕xؗa0EïQn~>rbLk~%:-Apt)c3\.vU=\!X!5jsfo}*r}= I<(WTq!YCc7ʧb!>pZ! }i]ېpƭB i;^W0]yheAk` _J훶u BwH"CH G@xD .+u%ic?o_+v޺*8oPT% γ҆`x4P+A}y% :uvȁKJ%Pu]Y񚋠P_ӷXBnMK;p>=e,;g"Lxkȳ!QxK{4%N|D_&8Ӛ.?H; 2Bn0L~>59n4RR6  vcMP6>ݚzb O:VňዢXO?N6|& EHoTZԂ64=ZݭaNqd|8(>،:16Z6`)/)0Dc,A-]<*aP~cFI>G_]jz8 hBSUSQ,Qdlyա-gKNu .82FSAMM:&2`I3)i?"L1ruQ&|àꭋsgB\"XlҨ*Ή/&wV=Ֆ %oh64tc#-,:ַ&OtqK6TR5I<>/0#?{`}S޳_{KY-΃(^=iLuJ>4A߼.PԕԑRݎ_ä9xƷHpoKb}MŢgy9+o&b&6V9*+w6m_h5LqhVk<̽<҆$~ TY66@^h³ft>&$qL ˲@r}eCmrs7ibyE.\䨿8+t IV-R[kPIҒ "-tiDDZAKUd$OƟM0<\H呿)~WlZlAݝ{~k0YO5So}R754Ԯ he7RKό$,>Q)մV,\qtp 'ܻr{Bu<0YGlZ2X]L^Rѕ/in;}!ytMiߡa1gb8Tr:cx@6l4cW K/w F>,SCY%rl|%7:4L5j(cƙ;2IEfK<&V~_2 QeU'%m q#H$&q1ڞ2:Ll-李ȱיW~{/D {!7o߻Nc+'xoU09'ooc]Yo\ 'c>I.ZIEkWFiDUeRF:7zO眦oiS1 15Bo{V"uM,/-Q"/L%3iX=P|d)_}}iڠ$[â-2$??5!jd$1 nr`#4gqj X.3ПGeDP2DXݶ~cց@^98u$=R2__*$oۧGo^+]V `r` "5[%>![ ̡f7Ne.l5A%5Z }}+ya6ŸCz譻bi~*0.30km,BSUVx· {4XDo\_D}ZϭOm&س\Iɔ$b's|d~R(0)FN'<[$} Ӝ $<bi'_dˁ歜yVoV-y~"--:Z"pS X,+<7gڡ}5f p'Jٖ!YY߅duff9:փi1_.Tt3{=/}t4OX/NlDv:m!gD ^W4d J'z5LK"{E=֘')9~t{տS[D}hQ>r$@IG8fz<YFKI,[-|F1+F𦆃x]ON /%nq֊9B5k]„R?Nۥd'$E08!UlRUTI eE|o{l nq/N$3mU_ERƚo([)cր4%$? SötЏ]i+i:[e~<_Qfn ޡIِ7wE 9v+˞Éπ]#ͶIɏ01>%8BܑY};U+>iBZΎe0*gsU,*M)!joE/rVEBƨ~U4]<_7_;_Bъԕ{L6kmE3<w3aq_#p1=df`s0}M'._G6`́y][ d:r c5o > endobj 2 0 obj << /Type /ObjStm /N 76 /First 595 /Length 3071 /Filter /FlateDecode >> stream xZ[s6~ׯc2;! p'_u6YTEIa~$N_2# pp@`1KXa6a)03aIM=L:4)T$&K fЩ$sII23L1!Z&$&(tKF@J<1K_;LPL"N1) d1I[< _ƀwx&b@ T$fR)ôH(İI{r뢜Dql<_tWx~id9#O7Qj#sWq@/13c f22ڛY]Lg6|x~]ͲhIfʖp,@f~Q5C|8lL/#p5t1;ai~m36|8'yUgC~{"-14$i|<3 W;0RHOnA呱A<﯊-gSK~> B kQjJKD ~-姲]n&ˆ&tQ БAHT (0dΗxQ!]OFu=|n~ ks^Ո\Ng~1./uV i٢˧2)T!YY {$h`C "1@MqjGF6~4P"aթB `sP2Mt;*i|mTo7mCT2B[S^QT jp$u?{YD~"*hE)x,~LeCH@-&i#,[N H$B=J,W"fɋMck% CY%@ <2MG#b@;g"^u.ڄvj#d޻@ޞځ5Ns- $kI yXHn GFdL`` ۅ"˗/uVc6^Q6.x%wtAVlmqo7R Hpw ܱՈ`؏6w9>lRFv$Ei,#sPQtݣV6rXD5w=b&6]rU[b=CMh刧 !)!IH0td=2X$VrԋTfs ?iIz%hRGXnv*W8S$]PL=`hMT*\wHct9ԇKdVݍ[m[2sܢGKr4sSo%ږ7y@nC*msoGAt=--M鹹 pK]Œ3?E$N-~dHI'O0{ 5e<%qc7߲ײm u%[+0c0ĵ^j9mׅҺ'*Apxraf,`R)G+r/\P.6|ǥxk懶>_jDi|zbC>ԑ& v6q誯=zeXo_<_ORѱ_(!/ʔ ykUW3Tme~ekՊՖ"Q*}iD@~W~ԛuY>~;MZ^ZcH ;ɲeʂڍ75.eP/7@ڭ_&dnWʫM*mj8+u9 5FNvw+b􏳫όdϤ6!HqgJ52v6}W#:fƞ (ϼGߦ|]{Ie.UJOuh͈:nLu`1‡6 T= l H9K:2/$Y&e~eGɚeb+;}Ň$SAt!2#(#"ZF+&K/'u2orN_}7 7~.96- MZ$RU"=v &U_?H|m3^@䲑K7O٭$j逇b&|h$#!.%Rn_+ڕG;țUâeȆqV,>VHbrY,DZ5!U "UUPx^{Q^B0E20-1kn^?z !snZBv%o-vX-m3? Sxy'nyZs{;uݬGS:`?& ^eLGIښvo5֣hm]tI۸OZ-ɊrnOTQwl{)=;n !t\s5G2s{U.qjJw{Dw/h;[I7NL[w9}dZ;i</o;#tNп,.&5͗\:0['^ѵKVK욁/ֶ=Vlqbڜ<]ٌ5}Ad8NQugu6Xs <9AA758D617904647A4E5C6539C24D437>] /Length 226 /Filter /FlateDecode >> stream x%I2bH>= library(Rdpack) pd <- packageDescription("Rdpack") @ \Abstract{ This vignette discusses Rd macros provided by package \pkg{Rdpack} for inserting evaluated examples and programmatically created figures. These macros are convenience wrappers around the native capabilities provided by the Rd parser. The macros work in Rd files and roxygen2 comments. \par This vignette is part of package Rdpack, version~\Sexpr{pd$Version}. } \Keywords{examples, graphics, figures, Rd, R} \Plainkeywords{examples, graphics, figures, Rd, R} \author{Georgi N. Boshnakov} \date{\today} \title{Inserting figures and evaluated examples} \hypersetup{ pdfauthor={Georgi N. Boshnakov}, pdftitle={Inserting figures and evaluated examples}, pdfkeywords={examples, graphics, figures, Rd, R}, pdfsubject={}, pdfcreator={Emacs 25.3.1 (Org mode 9.1.6)}, pdflang={English}} \begin{document} \maketitle %\SweaveOpts{engine=R,eps=FALSE} %\VignetteIndexEntry{Inserting figures and evaluated examples} %\VignetteDepends{Rdpack} %\VignetteKeywords{examples, graphics, figures, Rd, R} %\VignettePackage{Rdpack} \section{Evaluated examples} \label{sec:orgf215fe2} Sometimes the documentation of an object becomes more clear if accompanied by snippets of R code and their results. The standard Rd macro \texttt{\textbackslash{}Sexpr} caters for a number of possibilities to evaluate R code and insert the results and the code in the documentation. The Rd macro \texttt{\textbackslash{}printExample} provided by package \texttt{"Rdpack"} builds on it to print a snippet of R code and the results of its evaluation. For example, \begin{verbatim} \printExample{2+2; a <- 2*3; a} \end{verbatim} gives \begin{verbatim} 2 + 2 ##: 4 a <- 2 * 3 a ##: 6 \end{verbatim} Note that each command is printed on a separate line even though in this example the source code is on a single line, separated by semicolons\footnote{The argument of \texttt{\textbackslash{}printExample} needed to be on a single line with versions of R before \texttt{R-3.6.0}, since the lines after the first were silently ignored, with no errors and no warnings. This should not be a concern if your package requires \texttt{R >= 3.6.0} anyway or if you can live with somewhat inferior documentation in older versions or \texttt{R}.}. Similarly to \texttt{knitr}, the results are prefixed with comment symbols but the code is not prefixed with anything. The help page of \texttt{?Rdpack::promptUsage} contains a number of examples created with \texttt{\textbackslash{}printExample}. The corresponding Rd file can be obtained from the package tarball or from \url{https://github.com/GeoBosh/Rdpack/blob/master/man/promptUsage.Rd}. \section{Section examples with results} \label{sec:org80695a1} The macro \texttt{\textbackslash{}printExample} can be used as many times as needed and is typically placed in section \emph{Details} of an object's documentation. In contrast, the macro \texttt{\textbackslash{}runExamples} can be used as a replacement of the whole \texttt{\textbackslash{}examples} section in the Rd file. The code and its results are printed just as by \texttt{\textbackslash{}printExample}. For example, if the following code is put at the top level in an Rd file (i.e. not in a section): \begin{verbatim} \runExamples{2+2; a <- 2*3; a} \end{verbatim} then it will be evaluated and replaced by a normal section examples: \begin{verbatim} \examples{ 2 + 2 ##: 4 a <- 2 * 3 a ##: 6 } \end{verbatim} This generated examples section is processed by the standard R tools (almost) as if it was there from the outset. In particular, the examples are run by the R's quality control tools and tangled along with examples in other documentation files\footnote{In versions of R before 3.6.0, \texttt{R CMD check} used to give warnings about unknown \texttt{\textbackslash{}Sexpr} section at top level. See also the note about multiline argument for \texttt{\textbackslash{}printExample}.}. A small example package using this feature is at \href{https://github.com/GeoBosh/reprexes/tree/master/runExamplesCheck}{runExamplesCheck}. \section{Creating and including graphs} \label{sec:orgb3e0ae9} Figures can be inserted with the help of the standard Rd markup command \texttt{\textbackslash{}figure}. The Rd macro \texttt{\textbackslash{}insertFig} provided by package \pkg{Rdpack} takes a snipped of R code, evaluates it and inserts the plot produced by it (using \texttt{\textbackslash{}figure}). \texttt{\textbackslash{}insertFig} takes three arguments: a filename, the package name and the code to evaluate to produce the figure. For example, \begin{verbatim} \insertFig{cars.png}{mypackage}{x <- cars$speed; y <- cars$dist; plot(x,y)} \end{verbatim} will evaluate the code\footnote{See also the remark about using miltiline code in \texttt{\textbackslash{}printExample}. For figures this is not a problem at all even in older versions of R, since all preparatory code can be put in a separate \texttt{\textbackslash{}Sexpr}, and then \texttt{\textbackslash{}insertFig} can be given only the final command producing the graph.}, save the graph in file \texttt{"man/figures/cars.png"} subdirectory of package \texttt{"mypackage"}, and include the figure using \texttt{\textbackslash{}figure}. Subdirectory \texttt{"figures"} is created if it doesn't exist. Currently the graphs are saved in \texttt{"png"} format only. The sister macro \texttt{\textbackslash{}makeFig} creates the graph in exactly the same way as \texttt{\textbackslash{}insertFig} but does not insert it. This can be done with a separate \texttt{\textbackslash{}figure} command. This can be used if additional options are desired for different output formats, see the description of \texttt{\textbackslash{}figure} in "Writing R extensions". \subsection{A technical note} \label{sec:org00b2a6c} The above description should just work. This note is for users who wonder about technicalities. The R documentation can be built in many ways and as a result the directory \texttt{"man/figures/"} does not necessarily refer to the developers source package. Indeed, when a package is built, R works on a modified and cleaned-up temporary copy of the source directory, so the figures are created in that copy and then included in the package tarball. Similarly during the package check. On the other hand, \texttt{R CMD Rd2pdf} and some other tools and R functions work directly on the source tree of the package and they will create the figures there. The net effect is that a package tarball always contains freshly generated up-to-date graphs. Developers who never generate the documentation by other means may not even have the directory \texttt{man/figures} in the source tree of their package (but it will be present in the package tarball). \newpage \end{document} Rdpack/inst/doc/Inserting_figures_and_evaluated_examples.R0000644000175000017500000000047114203665044023723 0ustar nileshnilesh### R code from vignette source 'Inserting_figures_and_evaluated_examples.Rnw' ################################################### ### code chunk number 1: Inserting_figures_and_evaluated_examples.Rnw:19-21 ################################################### library(Rdpack) pd <- packageDescription("Rdpack") Rdpack/inst/doc/Inserting_bibtex_references.R0000644000175000017500000000110214203665043021152 0ustar nileshnilesh### R code from vignette source 'Inserting_bibtex_references.Rnw' ################################################### ### code chunk number 1: Inserting_bibtex_references.Rnw:19-21 ################################################### library(Rdpack) pd <- packageDescription("Rdpack") ################################################### ### code chunk number 2: Inserting_bibtex_references.Rnw:243-247 ################################################### .onLoad <- function(lib, pkg){ Rdpack::Rdpack_bibstyles(package = pkg, authors = "LongNames") invisible(NULL) } Rdpack/inst/REFERENCES.bib0000644000175000017500000000233314177730325014676 0ustar nileshnilesh@Manual{Rpack:bibtex, author = {Romain Francois}, title = {bibtex: bibtex parser}, year = {2014}, note = {R package version 0.4.0}, } @Manual{Rpackage:rbibutils, title = {rbibutils: Convert Between Bibliography Formats}, author = {Georgi N. Boshnakov and Chris Putman}, year = {2020}, url = {https://CRAN.R-project.org/package=rbibutils}, } @misc{parseRd, author = {Duncan Murdoch}, title = {Parsing Rd files}, year = {2010}, url = {https://developer.r-project.org/parseRd.pdf}, } @Manual{Rdevtools, author = {Hadley Wickham and Jim Hester and Winston Chang}, title = {devtools: Tools to Make Developing R Packages Easier}, year = {2018}, note = {R package version 1.13.5}, url = {https://CRAN.R-project.org/package=devtools}, } @Article{dummyArticle, author = {A. ZZZ}, title = {A relation between several fundamental constants: $e^{i\pi}=-1$}, journal = {A non-existent journal with the formula $L_2$ in its name.}, year = {2018}, note = {This reference does not exist. It is a test/demo that simple formulas in BibTeX files are OK. A formula in field 'note': $c^2 = a^2 + b^2$.}, } % The entries below are temporary for testing. Rdpack/inst/examples/0000755000175000017500000000000014177461505014415 5ustar nileshnileshRdpack/inst/examples/RdpackTester.pdf0000644000175000017500000035050313501141722017473 0ustar nileshnilesh%PDF-1.5 % 15 0 obj << /Length 1267 /Filter /FlateDecode >> stream xW[o6~[d`byu)bm)Z/saHV`DBt$mER\{CBJ&;;?YL^cC1 ʝ!q8 (HvJ+GSr>OԕM+{9sd|kIwrb)k-HMQ- #³rUuNE M&SV |R9=Tt%snFqʝcsKC=]r#?]K8 Xg:37U)ţBjZGbı%YŸT:O?x՜(Z颦!ϤL˪f8!++}1?zgy! ;ÓVZ[mĤ2]!K@˞V͔"CmztEa84DZ;:ENv~=q<vgqeM"2_|mrF.&LHwE1ub ;)8rt' LJsnfԹ 1H0f#t3P6N@P¡b"a44> stream xYMsWm98V-IzS)К!׻9D*)U:H$F0.;:"!jqZ0JB+J|KeG3"7&ߧR4!vk {?!鼝-% vS՟ c'#gNjD;SKbrp۪ٔÒѠZ2_$I"7Ǵ([32`?v]Zfq)f{tDĦY֔iM^5(8OUy ܦ.{}ڬ}bK]NCp'MuuM]tٶMZQ{E&7 ЫDySCdPeƠVq\RA!c$ҳPKQ eUn]yUb0*\si&KXia8bX1&< }CF7IؾbZA"Fo;#D&"Vx*NDÔtQYF c<""bJMcK<ܴVݑ^dǡ lpH' Òet6Ń+RHQ(ʒ:>(gZ8]p^9kZ L <ا-=ulCe\)na[MVx B#-s XӶD)\yʬ+k’CಈIgY]}M%<);qHCa]I,Y7NQmdWS}M0x)0ĐUU1wdնm]<]HĆLCO`͈z\z5 Ԃ#h/M:Fk> ØZS?ߴ/`o""W^-1ٔ@ h01 lD-V;7]9J U4c @U U,O#8| FRM O_^E4I9sts+nt 9&,CVgiGfm{oRShrħ7rˊcml-XpUeY4;L#oy(r\*UzaT+]u~k}c7Y[|ۡTGXl7ڔm\S^~\͇-Ӷ(B=#'ZgE׋'g; 2ZЅqqwq<#^at5*WUK}¾/]3Cf1YȾpJ2 !/ay^n]> stream xڥ?o0|TwkyTUjЏ_PX<{ v@0b>j:Ġ!mP[t&j`Y?45"P{|E 2dȤIsABE ݯ7]ہ"Gń&QMSH: #]C_./ p(b^R/_%(]"'(Ο"ҕ5FnCcFZ _Qn5zk@(e=? endstream endobj 66 0 obj << /Length1 2316 /Length2 19242 /Length3 0 /Length 20448 /Filter /FlateDecode >> stream xڜvt۲nԱضmutԱWlcu:vǶmcxܳ>{o1kV}5?9gzac[C [=3@hd t6p2`W61s6p|aU-M(XruG [ ϟ&N+bN0g @ `faac01s+ց oadn`b P17p3%sw03w22qYv9 L-6& |21f0233QG?~lOHV?*2?L-Lhb p8TG0@h1ǙI|c8YTNNv<Lp182M?(ؘaahbfe#GcNnm&&&f?t?0ZA.QLMQJDџ""nO&=3'' ,(@S[7vW.{*[T;#Ow=d/zG_#?AcnFf{~ft0J8[[CTCB|@3R䟅wT.Ti'f.Y8JXp22X;s]f-&m-xO~;T-&r-fv;,0<&n{32m> ;g'`".KZܜF?-_N._7OgdkӿV3&s|X;(/GAX?, m7G_?f\5&Or37{k3?(_%r|ha/Wn\Ckۿ L&_'v&=&_{|07??,qWGOo B>^vN&;>\m>;:]0qg#g6qm|LϿlS51q31]5 j}sg6˴($2s''|XAhׯB# S{Hs[뼩vu^%:_޶\ ڿ"kv MauT(* ;-c3PTqw~%`qG<Ƌp2TV[4Hr(#oRhIy׊ PQ꧁Nio^ ܊`Lp( `tvI$+WuD"T%[YxSFTa'|1ӊVV^UɟNΐsrr&^Voj5v;A0OGNѺ#fu ݹ>ǸjY!ɈQ$^7{jjׅγM3*6W'uPeM.L4^0F!7Dqb]!>'Y$>(*0"T(Hmt7Lycѥ\Ua8 D?gv2o *Vk陽/gpHYȶ GP{g3GNfD6Tr8 /D X`:6E&mYNӉԏZuos i.J/ϝTaCW.ѫP! N,JWF,1iE.r &B^4]]p#|NMl3pm6WSJ0G53W-l>'6~k(9p%0_(.Vn{ƚUGNO"p3 T,N 2SCӑ-oU3"Gx=I? MDeXxT$2geݲ ީM\O= :JqZ5I"mF``y#qVwgtr hқM_^M(R8AJU:)7y$bAS^r4JBzF1=Ȋ=ʞOQ?aʏmnx]ˑG[ٍJt!{ lDxmFYnì-]No`is*q ^\6㠷~ڏ-:\o[ qoy2XbLBRW,I>(M=!a3oSoF{O݀ny9{?=o,TPyG ΂2W] LTV(rDo*Ek~4Lׄl+V{v-%<1=(.m$6fʴHG.黠}OD)#;ꟹٱ 3:ĭw"G^75UPな hKftk B:?K_(|ז~(}wbiWzly_ fKl/ǂϚc[c:nYaC:yϊ,hTZ4Pވj5|m7;#*¶^7PK#~%: DP%D3y +I3q3 T˼S皷r):C\Xы֚yޱ >  d ?]usPd~j@וB3f#&; Q;p^:w|`uUs78:?_Ɖ)1Q;kV+p?WJߓ>& `}}8Da 9MYQ]f'pݹe1+4G %8H4DIin^甹Qo\( {\@0e@=k0,k\Gs6h 9u0%f@vUc~7}F<$s:[0廆/6LGOGx*  UB8:  !3!rlg b"rN /|Ld*j>َ3y< );5x-l6#xnbR֞ 5$@/q;&Ds1I(EKΜQѼ5=kbRAW0N0[}#-Hx! {$m(|u}gLKp@׫`x6;߮m#[QPoAw351)MfOH$iMqloC'"9Z!M>S?^H!jZ4(L!M\nK;f'u1'wہ^cx1MqK%fOh*%ZƯscc۟mcgP}{1.`vM.}Z V)g%(\9؂yԢ-[Si} K{WLx4Y<Ǣ i~V_~ldR'@585&IK|R.҈Y f3YJ޻{)l9}& 3*:1W[bh{YH1/~umFz]CnJm۷@hdF rIo)^ȅt5feF%9V(k9"Ӵ珽yFk,?c\8ӡLyGYV ^Qyg@ 7RfTBK )`Y8a,VX:hClg{?CAW) 9-o4[Nk/Q͛FBȘj&7mN %:F{z'h f5?WA ϶2+oAe۟s ~/r@8K.Xr4/W5lIPSXo?jmnvQɝ|gJ(Q{V1gKBwA})%aH7Vo qX/q\ߜ:í4{ UU`kZDx| Q8%7u{!oIOHä7SiU՝!(' Ż`X 'D6?sM\;'.#VDobPc$L{[͓q Õ=P BގHPK]vm|~Dk_8_uɾW8bxlhvn,q}պ;d?ɗdl wә(fVQ8VZ: A ׯ;Ʊi(~VW*~=Hxpv 3Gx0X^J-ū.#eWy;({&FW]M ~y;=W#8Xz{AkJdtЬRH.yJb79`v-'}ˮ̧{ff!{(O!gt˪E Sv m?hsGfm:r@)&x0d*Xh7V&V_֔YcH)jl%(8t(|!BO F"}7Nmȭ|/ianXٮ| Gմ=͈KF5|3WNF-SIoyuYM|[ xz J uloVƦ%sTV73G/)nQa9zӻ^Eut]\_aO`_B6;je:$*D᯶^`!= !صRᵇ9lA<4~RZ}T8>ofAыd(ʲl~'uUzuBf w ᖦ:Ǧ q։ƋŸ+Q&(::|w\Z[^..% ~*::gwFhX! ufKy3mu)2ძ'H0~\Xn+/k!|=7*)J/4{~","GjLP(+ՉPCsGȚ/(7nG/!V]C/}Oo6&V"6葫@4ROkfe~;ۏ; )K 8 ]y;emou#K!hZ8Xv"2[f*L{WL 0ɖ@PvLi-|J qLVQKW 3mȬh݂< ZOؾW *lS.|͑3j߬^&*_y++ag ]~g.(򫗶&|Iyd}_?a!v*f?G/9x-֍9}0"RQ)0ssD+l@RlJt;vܔQ$ s-Oc^vN+H Pߕ4FjjuIlf>7O+Rd/&&p[%A>V\3Fv-4 R+`PQVܮT_]nZ.7PH= Km1*HӮ,8 CE˃o:ѢCKQ (7 X\'6"|pͮQ&-ZB{'v٪\P[;Mג] )Wȳ0Ψx0ɽ@2W*|0!gFW ݈YH=9v`s^̈H|2zmdVmh:b**~ɮnjk͒_^R\)oEvY]{;-ݣloؾT'Ll[[?}-ւ03o<4ޡ55\ߐ1K;.nbdPR c i4:cO2zîvQ] r>5|=A!8g0!Gr%g6^}݋k]}x+ ԾOiLڨFmf$Z_Gɨ ecE<#$v 01xÃe}~lBzQf`YKޗ e<ԪM\νӱVľh3ujj_E:B2>i*;Աg,ƝR{fDk>=ֺW"bN}ấ4'v)l+[;UAS|W))ƼZ {f4f"'lÙY=e4\ Ulv.])Nd$>H[ˆ(0o(]Ӓ\X5Gk˂,Eu+H}(F'NzӤӝi|ODdZQSjNW%L#YFy̡eZICe 2\)BD=+@zǏ첾dm|P?%sӦ%-ԂMVL%M5ե_(+ڒ1۟shv0< <:Żͪ癳g-J,Ҽj"@"QET6Esw?$ߋ+Ε~/B{ v'i3jd("}6mܳ;F}=2ef$h_pd&lEHМ ‘P zdtǍ>xsU\d=HW pdf΍sgi32y8/(gcœ.s!3p8)R"V&cbtUҵA-IOqB}%zT1o,*7$Eb>g4 [T;xaU m\`1e$;+X;R1#73tCU i߸|/]]Ǖ|EGE@ua kODP49 F3‡ۺd,b 5;O#e0c5G12HRR̓ҺR5,"_zc6\=,?'%jZl#%eSv~knl=9$$q ulDu[gBU,ݵm*IqB7c&m#|k7?uz>H0!#eIySjw }b@HeQ[; !w]$[c-] }͜T-KgH}ǔC2&ߣ_,^ I;49è:ԣ΢-~Afsv]#K+^rK€X붠Z-)swnR~όDyP6^р+#RwB7Hoa={g7cMD6H)ox$s6Rî"2FMN0SR]=ֶT4r9- 5EI;ɸcd>ҕF%.}{@!= }e3͋)ljOJo̗vK_ [TL+zC65j˼Ԋ=]ŗ)67Qa< #&^ kV9c8(!Zc?"0^6P.q]FaPϳ_z;8vuΙGlĞmTH%bQOYP(I,1q- ,'⺭4=Jy,8|`_g!-&/ēϧ$&Jj0aߠ4qgq: g26 iO܆򞃚b 5vdڸ5y!S}GKT%^ xw%CM_?d]S)ߦ|YMS'/O?_Ii3lm =/k^`އ|KيJIIS~ɫP,?tRi@jf~V&%йTyψ%ǂJ<.Ine$ 17D:J)?,G-FL;fd"h匊?|a|t(ځtfxhq]$H213,t:Ae)d9f3<=_D(m!JӀ [X/2Ph";。@fGQXԡ>HysnR̤.l<bː<tYK w9uHo6b*_F)PX/N,k\+Y|kre?Z)\,8XWo;m!u]hͣݴ >h'6R[9aF[@8;N].t֡E쭯gɺ=jRIyFBIpABA&ZorJOf̼V/n&m{PŒ4*˫U:U7OgE\+g_v  3ޙ@CXb4p^"NO.XrUMb&ם6 tTpcv9ŕЫZym>hD.]n mgȢ*qҮ;c>q5E[)''hwK{8xLȵ(}1fvɨn'fE FѪ<3r:֭AGhiV0cݞP^BJn8f+RZ5l.ߖ?>Ȝq O), ~Bmʀ;'CMxs##L,ZBSfB7OM#Fl19|XL#͹znVZp=,v,7o1L 7V2Btޘ@@3m0eHb3%BW)/qN$ >ڼB!9IGxoD48o"֭Cջ-h!~p O_t&sè]ˋ4T5a͔DS@5ߪ1^ rwR`SVQ!K:,W#GlQ/H߳ fT~h;Ӓ3G;{M$Z{31bK,QG ]<4N+B9M#`^y&64Lz=lO%\ho'AX3N`ֈ8߳#})qP-Lfl˃N:z2nrF`ZS$ژM Yp>ԝ3J޶϶lKٲV0lCةR3-d)סyE\n^&s)"V'hpۉimQnLn&!mdlGCE}4aSLϢY4:9H$=6L/j[0"?k.nKܑP]N-?^=(S)cF+`~?M WuӺ?u,wkXlAaY\nA:4~ĝ5_HվG ^:EJ Ncjʓ>pK.y@x|TY؃ŊJߪjbD`]ZGf_vBr i .JmPZ| Qt_# }&<:>p?S[,y+0xV["XW* +D J}B0>PW$P?sz՟(AX`HdGkOI9?A3dF<*4R~..,DxhpFI5 帼?+YGܺG"zBG\<};ђ214_2Zð{Cx:J*J{I 3ޖM_U 01"P\U h"RIkpdu0pZ0l32g7yi֒–*:`:i 35Pԡ<`6M$rM{>ڍg )4~oK {RBQ HlSզf~ LFS}RYF3kRYnN{ ro_eKJ6bkH^ʊGקpCoUS;6h J{g0*%3C^ψK!=Q"qEE)cK_ 02j|Tx;_.hn̅X:Y^uV >˲98K_aZ|dV2(w[ؚ켁 Bj|**Q͇'SLc,4ixD T;:|H`S0C%vOdpǚ!ޚr76t" ^$Ɖ]Ng-߽,Nn~]Π`Y̚*c'Ml9N.i+-Ԙ35B/;?*]SEţzTJFP_Xh :Gj4Z$[AגռvCʹ0mț?6Y;g/eyG|Qz -lK?* 2/m.)E79RY ﱩlyfƅgNI@ci~ 8q*Q 4@͞wٸK⵵U 'AxĐmJle_o'n-_p'Zb`nK8dEm*1[jd |FBu7ӞW'ANr -n;jכ3avEi&i6c"S*1oo ܄Q!*!T!tV~mh +{Kn Kn5ÙwMHxFl'tfX(, WEag3:xZ9nѴB ,%6l%Ȍw R3^/" b(uM 8~r /0)| e*Q~BF!p;nSijE7wjP7s'RFwoZ̬9:~܃Q][:Uˬ8Ôk{] Oa}KJ*8N>fBA|HliOjGQr75t!TB9Y Hz{Px:Tjk}Fagg$ Ǝ1 ]} > Y x@6 Ҩ$UA .k1-t5 =Q@ VzԖd}R|o#ov<2} z25`m3 m6#gTݹ': CZ_ExhO "PK|AZ湇zP)]9\ĒtEy񥰕"*jHlfHLN}1iy'gbO1m=3]lFKf*-Di^42m;9\H%,aYԅ^fM-|/J,gNPJMzNq3坅 Ҍe#tk2.FlF3}0)wͣ0trt}|;LzHn+ZM+mop $2^n֗LS9h5Jq"6a 0K18.Irµ_ WQr* ]#G_{(b^\a_4!LY3zA ;F(vRJ5ejAu$ -!iQ+zrINhm5*q]3jCMFAƋz#;)*)#.zlR%m׬WzGA{V?Qj-sQZ.#6뻸"Q` oL\5'u236:n>9oƦgQbD/OzEOixĢ1o,dPMG%ه}Pka-qАm^Xʵaʌ ӜL"J`Iv3SUu*ͺie!2Vʢ唌 aQ@RZ zҺaS -~%f>zxƌ  ?Sm\ Ecx,pq[cNOz c2Fvm[a(yQ \H4w )WKyJ(")Y(z2'\ld>;LzWa)GWٕa¸-/5|ܰ[TXRBbXG.9o8}7.B8|lε- 7 2sz$RuHjm 6>P1~^ˊ]EjlT,)G}h$୪dQdy9 U`m пW;MEb@eH "`'F߀װ uX E}=F[O{z"p3ak+DQxƷ^?BdY(im$xƜri[MzmG&ܥ4Te t [0\SV/C!0Zb%?CoY"%%->(]J? Z ̑> n}hd^8sGW.q(D"°n))ψC}BgwªFR R{3cbӲNyj[&5{eSV"rJу`lx8ZaheEP+25Q \z آ |<o8;c:'FnfuSܜd A' ñ;]"卺8sG'{}FY} ؛[ڊi(ZdBwَBиu&F&L+Rz]ҫfCު\a+(#uw0Of1:v!) -ί:!3D\^ddgV*c_~QM*pF.5p <.~wo!I˧ m]CMbIh; NBxВxX`h]! xʇ`{ B7詓ݿܗy ޥPA#J^Dwu3:&hOh##Ecԁv9h&MEM@c<eQ9=+@YjMÖ\uJPZ/!wwLp6b<fP]S᯾ƺ@UAվB& GAw}$^;\`$ΦbO; '='zmԈĿ$'VEb+vI.fj+HTO!Аu,2\M/iQ3J6Ny M# .C3)RdF|Ѥ1pi6ݞڧi{d4:NpW<_\xRsȱQCmföx4_ A_xJɢ}6QП3(Nh@ApLPxH;K|#p??A ׽UY9ҲȊů4DrGV@-l纟?(}RnߑQCW[K4=+3׏JP,0yB%0[kB́_K3 f<8{cA/LͩΧ<8//[A{N:HF.We, Ɗ kfBJ}ByU9B'(}QF8M쬧QD~bߩ)IM9\YҜaD9Ms_h{-\T_Duk'+cF."L9Cw_XU+_ τpn'K>h^$J(9ýP?`ITXHS(mKofނ]%0`3sE~ x1D J/0n6,-5XiDlX/]:E۽E I2RόԽϱř-o/&doA:+32I ׻no>s͎YO/g:tEyt ۞D1T0Pclj(א236Br'8i4F3Xzu* `(Ў+/`*x.w;CURQtih6):OnD#{.>7T)9yߵm%jUࢤWIQ8R/n)Oj`:2j*Mi0|(" n%xpv_y <FH~G> stream xڍwT[.RzIWi)!Hw^(һT" Jҋ"G9wZw{f=白p3RC5PX!0H @ QaH:֓q1BáXN P(,!" @ @ ꉰ \2nU %]:]p; c +#.a u1pwOW} ҄ɸGO1up g xں4OA_ /_0 uA:p0+B1(?pS4 P\Շ#X0F0cVwSE]_!0ܹj.dpUhpk9q8{6῍_j\ ~h`+^d~'uoÿ%20`ap+?qj2o~`av(Wg[ 4UTP?!Q8I$qǹEvG~//5!|G tK8濢?ix8; ?P_u=1Cf?gWnpo6eWb ?nw9I?& ~]18/l)!q?MP n䰿KyPvOD\uwᚏ~`ܘvEaq.\{;ٯFKJT%iI$#IH`KyM$\˿8#@dÝj[Ov2NE`{GLjLk{BUp/\Fا|1Dh}y7*Bgj{dNἂzIK[m -TQ/ m؇r9?>7y Qx>-lN-*JȨ0 _#.8,ooWrsM*zveVǫz,Wz/X^L(%`}@/Cr'vx%eg!t{Qxd%!gY}2t/Q۲}= W?Z (.D&i Zh"R (n}}DJk8Uy9/oia闫9L97[]^o0͝7q}g_jxf1H O)ޱkjLKP-pԛN+Jn^۶7-۴;& ہ=9֘I8pd0n(! A_ nO<@'z|M\;XJifF!G}*Ə0?F >Ml&FY\_ܸED3};|FeV_#2F娝{+ ֪={fQ?r2  /-m2f|ͧ5yOMCe !Ŕ2g0nWR w zna*EOlj rN:?q!f\2ކ/ABuO3 >bu͏y)Wc6j=W~1<ѝdOϟo)(ܚZGmye-ȐEfÛwȀ{1-k,]t>ߛnGaW Z8$ܰg4+#)|URFc>whr0u"N[Z;o<6y10/|ꂚ[ sE[׹2Mσk/g9>j3THZq`#삃fJ7#E`‘{מ>_+wiLV[|UϨY(*_6S<@X< hkMzV":amk*_/$:c@{HKmY oZ Uޞ4m49miy}jFXھNEMo"ɗ^];io8y֗h^uЋr>h1^d^D(NĢ"DنVK+L!3<)LJ@i|پk4|S|8vg!! s}ME&WAylpN.1n sؒkz[?wz>:&6{y|=:1>/+J+ x:,3n&cv7,kDfgvW%ۢ =ڭ»'$jݱz_od6$R?V #!ߟPq ]Խ:` i'C(?fBSi]UZP$EocND~O10HuŨobTIn=TwRt2q7uAM{'Q K{ =S#[Bص̌W5"O?H /Ƌ"3ؼZkޤa{z?sN~KQlzU{ߡtѣ @7{}oZk~DWtB金քog$U^ _4n\ + mK[~^AD1?URJ}*ӤBwɔ;: YalBȒRZy^\Q#[_7!_V(Z)~X' e\tnn ud )eBv}Y@#I%֣M o'̫zv_C-Aթ,snFJَ%(a9ּN$ܤ78̺TA nH! c4ZuO+,b CQ+A$QC+s]Q;qn<6 {3,6 }wLZhqV0^QcIufDG}~|6*I+%ԔTGOdZ<ᣏ9DxV|ھ} ^ߙ=Ǝ0{ K6h}>1;{b j"?ۙcҴU!Вn>Fr} B9ф?5?TY4o2*?!Nf-9Ľv>,k@ԭ~>{ạPhZBj{dNsR3`TuBm~jj+&3HW;Tb;6HyB eRAQO83F{;SHn`ikr{+)vN$MwcL[)k0 t=EOڕP%tӆ~$HYXT7#iqF^UDBζ4ΎVa!f6̣b\Iޫ?71:HhZojC&Pv2}Zuj[;~N@V_bܢ 펡S{<2fo[3Ev 1Q:J碟,e@|DqoiȖ{| +A// e{ ?2[֮I4wؕ ;Dq:G o *lG;k {t+<2аa'X8}jaᡴzshqM~Fz%m;] .{vE͉un<%ir#SlV!z@blslə^smHWTOdv544ykEuFL*u.Xv58jn>|bZ(bwEn";3 Ў7VT+?08K.fVQa$hA{gF%tڥ*C%aڳ`@#\ݨ4)9KӍ5(3$} )PX$u񃵿eI']PɩSV*lm^Uş]F1]WՠViDž+j]4qA;\ю&Ɵxr7:~()iwD\=\p^qPk+r=SFf??jkH:)gJIWq7O}{!zКi!ǙFWS#Yr@٦3a#w<:S]H ᓗK[ o5nm}UFmta!Ջod%agmǐ˕g=Z+&\eHo~Z;IE#كYEIWHYvQS~,+֌yrLE;*NܴJbOb[`8?7f]ݥ %1p;Os |fh`Vqf=`@0򝧨qk̪cuՅXEȶJn&9AǍ<7o<Ǫy8vKe2-v ?7gOA6\iڽAֆ[H& ai {7rT]Z)c=yr3 :z#AA&ܐ Ó$)moO}0\qffH\4P"v}NdZ̬K+Aۣ/ endstream endobj 70 0 obj << /Length1 1400 /Length2 6326 /Length3 0 /Length 7286 /Filter /FlateDecode >> stream xڍtT.)"]2t ҝJ CC4 H#%-% 4(H{׺wZ|{gww?L-k*!HnP " y@>0@?$$|@迀W1f "P7 s[;du`Ԁsœn* r&uF8lPC@`6P @C|wA+- (7揍Z+ ^˫bg^_nOAaԋ?ha'UnE]ӿ:K`&Z(?$7 !So UEnHww`(Һ#Q@doh50w (!mQd anJ0/6 C?~_Rs7دo * J_ ?!JlkeCQrgp`WW7j(K B ^8Jf \~~~|(c >~ÿZBD<ؾ&Jړ{}L{?̘{,٧8iV4 R2Ԕs9<{VKW-pM͖*v}*' aZQ#B>4mڨJ[1>c陋d!)RV ixWUNF#jl_<`ZuyiD5s8_ziU=BD4 8K9WY;oZ=&Sf:_gV9j=W;~*]SpsǁK'tCwb*d2)i*{K 4zpɛt>|eCx#ʹDBK,{ OKG<ϏLyroM.]A!whY*`B~2.1ג'rI36vn#=Cjk e}׽m>ep\$)?6e k7olobMׇwnKs+s =ž2cKK*'IduHR&r>%kz_eRg53eH.JGQo]Vb~WsMv͜6aQ +v+#'Ǣ±,?upHX0n6=hήx-0|/i?5FX!DF_uޚK<|V%&jxYɴ蒡i+bV,*z݇Gȅmʤdf-WӇѶ1EcǢ|oЗe?.AUЄ =h9 ,5.c%έ?8*M yHLvy#==ǰ .gZXy{Si+gN 3׻tT1#%۲BvIWWSoQ8sJ$B58?1vZ,0idƐcLh^E\2sϤYF"mNc>mhkI:^xYg2:P@qj#9 9VaX`tv e"h[ c4! ۹>1 J7~lg{~c=RixV+A+ca 3lV2D?-X y/8W&$uǦg{ա ^;ӛY74-59|W_n8+齫)3gHJ Dŏ鐆Sԅ%4aRriB苐6BMX_,`ƼvOCL\"*b۔-m+Hn-g|UkTrH3Xٙ;yg6[}5'Y3wA|hraƤ+ATq5>]AE`B־zCX$ ǯ.O!*hiCMdVK-մYo=#tX+8X/3/A: [L5V;d!oqNEFG><&j.E2̘o?!Q-B |zF7LH&Db'qءAY a~QTZIZrҌFV.^0 ݤdIx0"5H{f1tgMspӆz63WJ`N:!Rfi䂴% L ?E}dMj5,qY4Hc=KLmR' ` rg-ptAx^`eX]XO'վ?8ѭ(;~llOKB )9IJso6=u_^X&UΦSdFӞ/aF v&l,-(qဟ5K8p  j/21'O4Am6;yQ`Za8 f޶,/¾5T^y&v,9&jmdw*5¹ڕҖ?f#@N$xk%!h xwsѽ־GwckW}QTi{UO?: ;ck?rrc S WsD87}m`>9(._u<8sGmd)Ȧ7[E5j[8g@2g᧢.D:WIX1|fޘs@]JjyUגsB]C'XwOGs'8y=޻,%|/͊e3GXSvvvzMlRyjSf]<sn3-R6f4sDo'??x|]NѲ5C=-Va6Oj%&PEHi4@u:|L w 3y%$GSVô{Q"gQAsifUp"~ z87޶eQEM7s ?Lc)5P"-)]{Y3 #Rs%{{0($?hl˼.o^&)$`4WR S9 C;$CHτ@<( JWψ`eRFWмuZ/ +Ks0s{Nǒ$:3Q[ԏE@|OF Tb;l7oC:Q9iUO;{V2OTX0DޥЃ<|4/`f7`wx0ˮ}H ݔri$_ѿoanٮQrXgkچAjG0 ŁؾR{?f$ 24ZKR!7g/z5e& P$H 3vz%׺ז[XQoW'RmEflCz j+St^}as3nNW+X[1eU?0”EV=`1 MzƲG.3wMm>e,;SH@&OSGWAHaF^ 0z٪"y)A1\9 řu Hn4>͇>б6y?RD=%秾6QB6svËďHdn;\YTBX6% ;SߚngA艖O~hntX <-{;QROfN8|n[њO~ Ǧ *hW8e(=?#'xl^͎GPdm cq{U yi.KBG 3Zv*+`#׿J@S+Re\A;ЦS񤢔檉)Mo./_ /> G;ƹX^ℱ8A>!cjnBRSdMqmH|x:M۟PT{41ێ,xL-hcx /y8ٺ:H+iEcD<xlpN;'ʢ߼%t\%,Kv өʽ.|G[hdHA@Bý{ϫ lM\ڂ6chFI$l7aZm#{Rj| }RLbſIX:) +UuP;=S(qP[ާeB'nm1#2r#A'DȩEnL_AbEiI*ػ5?7^NHvy(AfjEiնdܱ:`lrկ5-ENm rO0V*+ >Y ~?HJ;BCiv Rvյ0Oԭ6w;7-`X{b%1인\#rdJ&3'*ʥ5^kf\M S&=~Kq?T=G.YdG\̣t\u碥/%&zXG,w07FϠU5>N+`Kq z/a>i{}@7hQSg"1iBz"k2 H6@A\˪GZueǯʀDĎh(:,أn0q:dtglT\jB/-:ю:j 5kP8@\^2DP,lĕ}&YT@#u潐n'J&4ڙ&"^2QO"2wVٔ󚬓Cch6[Z10vj;/UzrtNIN|{Flm>`%U!1Qd)hoL/2 ^()Ti,qyn~GYXpi$O^Z?;cpHW8wP46Ѹ# cv(Y\}q;m򅪁"e[х45PUo i)N!z)֌Eu爧f{ ];~q=vB9H꽁;~Sv+q2۾~I6Wp2GC3`!^(L[;yqN%W}ZC1]9xAGyRذmW%XJ}]\ϙٿA''M>9lKoSBFt&-ɱbjž )j'`ؔh94)s/:E} :tYr5DQ 773̇/X M{UzCrYU,ͼM&HXuQoy{Z%4ݬqZf{-DzǝB:oqϪo3LcdBhGu7[uT1j55:d$\{*;q{MM]]ҝq,w J<#a.Y@viOksGvG`-ʣ z"Ж K9TIjzל5v! -ίa<էޣ&\fmrIQoC\ܹ'^ -Gާx|0a8VP!VE'a$ln2SGJBz`E`BZ;a/܋)xq"mq5V$Թ%lO ]lBo`D%Y"T6M?,"6y;a3S'^Y>KIp{* J;s{~{du~IQFTIn%w+d{r҂yHT:v=9+xzMufv@ǦEh"줴sqLcXq@Jy,qhܖ'/_R6%frwy3nNwDŽNSUSr]8;k7bK^sb DOO$4 2 ³%-2O*~$K wK/:` 46! endstream endobj 72 0 obj << /Length1 1400 /Length2 6146 /Length3 0 /Length 7102 /Filter /FlateDecode >> stream xڍtT6 ! J )9tw 3034H R1 Htw( JI|s5kq]#ABR!H&0a$ KFcu`4O4=aHK$a!!9"R2 8E̡pEB]kuxp@ :qF(2.h %@:P `AA^GWÀ. 3b7B8HU8  w 們6q5$w%n`/ 8Aa@OU[p_` {0=w`@Uc=F _- J Q QĿS"!ر 8;:j]h(Us1!!! I@|\7u6~#'l@G{A4J u@g(X5鏌]>X a~}{ʚʚ:MQ bB$C*?b5N@O1b9xE`Q ?Cwῲo T=af v|r%KAVto%1BQP>-&X!׳cW_6,`M,sy bbc 468!Ŀ6*!عcտ5 [aߊDb%:q G8HV7RͿ6poc)ٵg< Cg=m7fWTOo5\lL6hpfh8D<9Da0Ku'#zGiws;|^wbfWka>ǙZrgѳP8|9xɢK'RQɘ\0>=ʾaNM > 2,/INګށV\>P&WQ"h*lcU" LM[\3NK~z} Zl׷yqO]JkY\7莊eT:s| JDߴ׳go7ABB1~$vO(̛:2L\|G9*s !arZ_eo]jk=V'y_MM XWc7kC":$7KKmh>#LOʽ{,K<~gshe[]<ӕ3o>2WNgȀ)IvW W;ƹqc G m۷=u.n*22>ν> ?ܪHMŃ%rN,㎍p7VfJYx[!jفmu +c^r<9u/S%^ʪzLD= \e(/DCg^~Q1wJfXVr?b&ơJRaJIC"3E]͐J_D%5_bbHLRZIsGl H"b:>Բ56>v+ FLuٛMUi7(saod2AB%2MvkN&3{\?־z.`'w EKbۗo]}Q=:49xjC} RYg>4F]^=<xK<~Ёjc7تq]TOԋ2H1317Ju4Ot^Z{/?:n _z0;{iBK`VKO+Z?8J龢Z[bf&nh-GzB#+5a??'-ZoB{bn2hMp s8?gVv7D@D ÜiV@N*ƛ)2n$\5ꞁ2RmRü|}u8j!倹i]wJRc^a'Đ^$a dOo v0G[y':q `a?~W/?/1vQVvٻ?nJO4GRV e-B-gnսEy6S-c/ߙZ-E @tE}@N.I:/ZyF8v= $ 楫.FGMB]Cz0|k ō$Wիݗ"Z{@(9h,sbmkjlzh-%W(D `IA>yglS"᧠^0RW`2ۧay R,d^wW3~KBnһ0*Uϑt2?\-paXV#SLd|i;ېV{9Y:j+n'ו)Y= abDSB^ T(x7Hg-1G4p&mϋܽ[I3%Nv %-ʕ@h8Ct#Gc^fH|MrLDJ/.8^M*qp9ZCaγNp* PRV-TI.s۞ێa vL[a#} q(H\.rfmىӂnȏu,Na3l"8E)K`~$fTs$/ _RQ,TE<2xvKfjL-nF8tӱ daZQK"0u|Y~mj\5x h"R;*JEވVXz,Wu,}rE4GeJFe1D绳lx*\37߸̑A p[3m',2t*.ލFVPOAΩy_91  E}hf1) opRd ِ6Bwzg+h]|~mRxJs9|yZۈgڇY_ k)FC:޴βT&>݄7pO|t47hћ̓ڂ}8kF \m~HjV)}-+=H3cqII\ {Y7d!3犑p?Hfto3ZvBFH9$:}frRxaR3$}gFbj`cų/8'k#/86 T*뷙SӰlD:n4RY4B^} !ifɫqWK,phc"łog$ʒd(FXA iB}fSd++sj&\NI. NUr~0íޏ'@ݞ[؉x1U5riσXjr~n?%P|{oiC2鲥.k򻞾gNbY2OolCgCEtpWBB>3"-\WZ~ߊ#dktoņ~b/Gr{[rnԚIǴ#"GLЕ uل[?ν(Vڔ`g,ɴ-~+.t\kRSV-q'9Z0vb1oyxQqeSY6Нw ,tZ܉k-sb7iAMPZ ߻kcWXI!tY6ھvxwg&Rqӎ d4-~L5r#<(i9ZyIhA/NaU6g_vI~f|'GWXU fbED?e*&8޷ev7:;3@kaAS[]vWn\-fڬI`3-~`O;^ea7ie@ OTڼooo][k(]{_m̋^ !_5{-u zB~̟&w Y/elw~axZv]M1G]J׹=(\Ǧ6Vg$ь.;E4BM5 8q>IQNi2?ǔ ]9|RT\غ-AX=?7}b?ͦuCxasQARҐ6χTuxB֕r ʏ e:]OPk?HjOr+[\,*k}EXjG~RunC䚑yPLOˢ8A[QU:Wxl#ށ|$QuUhpWXCjFD?YD\\X,ө>Mi 3 2O W'7!AbŒ1{({&cjJX @ڑZ+6I]iz̰}M\θO=M|vB@4!]ayMS2\qЧƧK_1t>!!YAx켌I9C*ݦYE#1Gaq0Yl7?7ϭؗupWab ʎ7yhcW"luY~28ϥ5n F~Va}Z7h3L̙W(`Ը:h;fO^}SRחhdޱX5V+iTl^t="QyG{MM,qSMSg+Ai~vWҥQZoBb##vTtMa5笫G^1 m.ݑ{Bg.|, >qVyr[jU?zMrmx%ʲɽʷ>.aorIB\Zk]3"krUz<̲Cw,y7,> stream xڍVT]$e$RPSj`f`r DBJIiEii) i %U@;{׺wk{Ύ}k*;hV"` 10XgzX|po~U ԠX|>B$i9 eՠ~gPT^ʿ@ "++#;c0( źaPO)c!p ŠH14UAPM>p] ݘhc6E`8oD(|/j ?zD] "7_ٿP (W 4`EP@"5z X=PhrvՂk7±@)0,# ½Yˌ?[ \_x;@ @g t"Pf˟=~D6O<-g43誙[* n.t'*.!qq ~O#(*j\@?o_5}!'X8Poۂ0M)z4|=={~Dx>ZUEW k@KDh F,U }>(@Q>`]phy: v.q)i #豈8^ Ph,>o/~ b0xY<kShͻUwV* ʏX>Ma}i_fEc:>- +Ms6^E77:$4&z\I!j|lA@ت×{(пK3l}ĊKi]ӲmË򜞎pbE9ɅvhFr.t!$ q6 GA}XyYmX8ޏ\ǩ0ĕJ|j# XHJڪV~fLt3;^DRk;t۸ 2*g2_^ &/ϟʵ?ǥ0ͥǚ^q- DeLA:./} Qڞ bT.8pNѱ/J";daZcff NF8ít&ŮuUŰb`WSPE1))9(xtƥ9n=yQ K4eLPL! &bnIN>g{WQԎ9l4EkK>bw$̈b{dR#}g|c[fMz |k.H>IƢPޝ/t/|՜&%2TXmL]}%ֳK:G nC&?,Y-z0jg6(𱟮LϬ=, ̫7xHZT!eh"c#{SiLͼ[΋iy7rt^\NX^tڽbHr8nx9ޕgrLexr"\h 7RuO$S dyYNj?=ڡ唶SX>p">.E9caIR<ŏ4vRUOjC^=PwiFn zx.,!feap7Hz(f9`ڡrZ.݊B`ǽzp"OT1c*I\{~̌kˁqzWfCp*OgY zP .DEE_#.3 nڴDD2;ܞG)HۈV_zO{M7^IR$c)SHuK(~^@*6ಲ+s4=2b6&LL `#2֜E[u8j b<}V,:d3=hk/V{\.ѦĢ>ڼMOkxkxJc[dz5żZ.~|p d1s ֋7dcVDM]?]snyxvVNr>HF3O{EiZ)&+ةm]f4>qK}`$JZl׵ߴ#r[KXS5LnJCۀ0 L[+Kn5<,bW?"8q ||mg|- \SnYuU޹99Rk [Kf3:z*ڡki~$bVy!,UB-FŃ ӼWIxWFijsgcB>q+m^WZ+5Hᴛ&^ZB݌RoS9R.xmC_ hwu =- DeID(Z9 gM_ AB79 GYȤې,Nn*款ү6cXuWn%d-eHQeN aZ,ׇ ߘr.v輁qiIzq:N9Oѹ,L LO'yn\m!^οQRB8v߈u[LjK0d|4/:ʗ- f]DOˆDi Xt'|k7m88gh6 *mgO .sʸ2T1$B @->&8s%"a2@o(gꧾ4]Q;m:r ~o{W 8I@d<(Ҥ+zVy%%wlљbɵSd~8Oԋ:S+MRiٓ;/,mi]•GTl4O{krMGKNݫ6RLl Gdw' x.72(Wo*w͑F+zr{ Ў}5't)"(t4h9E59@.t+INzq5$;6 4dj3QV[ic6`Wy_>?Tcu/h?0p'|MU\J LfKƮjt,ՇIϹ݃ -Cf5nwNbgJK"_f꒞tz.0X.#j3MHVFX{cЇ# WK`bUwm'c I sxQC2_k5E;+z"<_"'o(* BT,dlz;MfM߱eJdMTj. )nDhkm.樛E\2_`v]dG:HO%e0%$/K,Afvۯ'@]VhcRhUD.&R[7JՖ?=bŭR4y7tR2 kté95f~Q~ʿh9MK3eU/Ø.d$(i$pVayScD7N˛WPoJ Ak,FDWz[N`R-ݣjỎ/{E 0+V "'U>#%PuǢztC|FD-N^b_jvk!l00^FSSP跐V9䟃̢WD-%pw/Kk'Ć};LE9c!mÕs.%KZ5H26woo8N$oF7YBo ~N6X<\}/Qp}֫Aflg2#۸$y)Xb_c^D|'P9A3LخUԾmv;K{DcZpڋ:6SH60}y2Ԁ*{b>r`zӳ׼euHPrH҄MtbFI)p$W /B/S@zvUwj.SXC綾 Fe.yB4bB//L|x+v4!r}bnP?*ƨ|\f Jԃo9U C)ME/ 3T\ =iH$oG7H?G*y8M؀CJF;JORXFo?N.rk 4T>, 9 Hw-^c vk0q("*ML֋08}&~`pdr%[L-hXL.'2V3rHrኍAyτk<iU+ӳ[ hl%^]#'8@61fk\"w(.3ȅ9B"NTI[3á%[5eM\ VLgRy!|$alJKShyZ51R[$]kV#qBGˍAo~3)րSSm)7QYzBL厍 Ta¯ۿgdTwksw6HO͕ ]\Rjt KI-giB;dQpUMNF^0.8T* DTNQIsdL%zcfO:DiG =W6>!Q?JC/;OW'#]#i=Sl"ÌLچɰ^=H"'k2P(n(5Ἕ6_s"95QL;wҾ墄 os& F,aEri#׿{ӓ ||ě(xUKl `P +&J}VX^(U |R9AKKX/&Dƽ,aB\mn* 9<+&cQ?nr\BM&q5iOuƛ Gclw\na*.n0ݣ| }c4`7y/]jO}c b\Ky3/ *oԻQN .MgY<$a*fn 1U!ZtX%JA}fs:HjLUnGhY0tw[8BK6o!Nz-r A&{V|Zߒ\v )zq 䲗bJ']RCB?ib74gcvxBp^f~5 7Hx|ļ~GkJsdHñ2U2Rp9}s8 !-Y>;ijq1 bm vj[p1?#Xk}8A`OöỜ^Ϩ^Jd$*jIBk U7gσjAjȞ.~''Z3 ;h$;k)>$_ L\0n'@ k=?Si7ÐKt'H!y$X^eT-J3B +T54D f)b\*gS4I(@ endstream endobj 76 0 obj << /Length1 1403 /Length2 6102 /Length3 0 /Length 7066 /Filter /FlateDecode >> stream xڍx4\ڶ ZtE-ʘ cFDD JtD-ZtA&ysk}ߚ羯=u홵9  H:JTt-E PL%4пDfP TAh PD""@ @`>Eq }=`NhLo<`^p! 3 S ``g_L|ݡ͘ݑG@#EyAhOh:"@``4C;; uk9; HG,eig9>AQ) """3B8"R٧[?3\(D13X+JH An0h t- jKPZhF J' E ea>P v5M C@ (د' & /Fd`WSoUC_b<<@DƬ"UB> B јf@#҃A(0+9ہa7`O~SZB}`i$X&UDy0rGLeo8k晿~Ce{HSٲFosB5Xjߏ:AY HQɧ1Idָ)ӗ$6^~yqՁڰOO:v[q,-SzXgxh^a?ş)]]N_SBjH*~驓rFaq)%Er-K.,kMlpS ѳ)>-׵xdm])9Y)2g5t0cZ ߍKX;,)=o 2Fwn$+ID&M~se 8l@ Ges莀з罰 fӻ$3DhE{Nvk-f|jZdoB^dQ~Ak{Y ŌV#IrR*׽2Ʌ5ɥ -P5@^z˰MDaQ[+g=軉ƝMeˉ|k`;ҠO~8iϷPǤvN=nϔfkw;wچf)àt?{D1AESuuHcwb3k z?*(ɸgIVpIG|GIkFa9;6i w97R]hv3}je>) S@ga }wJڽ 󇌪axіwJ#( -Z\ډ6ߪj.CjLlhE^2ef6'LbJ]̀yCm,E=᰸j4? Nrn(.Z!`rB;|{UF_l"?J"&ٴnŽ|cŵz\&aF"ϝr4[rV}3 q:V2⿘@'k+vUԱ͛-] 7C=]jU*S+7Q^ o{ƴ,qݛ^F*iE9Dvy4C9d4OJZusYTM?WXϏD؁ЯƃZu#e(G{Öm_&Z4ei/P L]4|h!+iJٴDWnGa9ŝo:BҋtVn@AB/Y@,-dcK$װ8*Y7(9ead#Tǎ[QcOd 33Wӆ/DU}Wj_NTKE0H>rC;򮫾u) #\R"W|q]ݜ|l x~|dCqV8qeŖ7d'Dr\77VLn^ vieC$~),GPX4Y%Lmc4~VFe#7,=7?) Fz qG ,O~/'+ wD}/:`5,뽠 [[4_eٜl*L c9 )I?JI%lq v &25{H)J[er%iLuaPYIET~vPQ` ~*f۬Mx2Tddujwf7 ܕ띌͍D{Qsqi݆U[]2}s28iMK )&*=蠖ތț%HfݧRq}SZ .զڧT>.-Bx"5ӯ:V8bgIQ;eT9i\dhtrykuB?'hɛ.~ W!%j{:}z'bKE&4;ҵSKctm8hĆW!b2aL koN{YQB 8L/y0bBD ]+*Ǻ| ($`Dh5^2/>y*37􋘤yCaZ\wNLuʝw>%WU~]П $^PL8JU3~ֱ!ߖ%7=[* "O "WJv^0k:~Bc4WHTWm^3&R@%Su?_Τ6[pf@rrݩ=;6\T+ =} 7~b%3aZF3&p(;;TisNuᅺZ$ߏ[dvIiXio7Ϣ' zơ^!]SuȌAwimENuְ>(ӹ Y z&\A G BԸw1j"ۮ?q⑅?( Xuu,#=Koy-owk/N.)$<)=.mN/s‹5yMʬɄ1%T BZ2 l&/B^h✚ڬ Ou,^&6#D-+WɷꠂdKҎeT-s7]xpr6?^`%Fazjh;ݝ?"ړ}NqZzW7:B5@ <چ@zɊqCnL9{K OBB;Cf+CeuE+\2K֙²^Nnǩ_jx8HzPKI|m^mj<]%ZtIpqm3bkޜlCPB#ڱ ˝/a=m"UTodY= OHBjNERYeeюv-|UAFcR sij~.|zCxrsOJjuÁKɯ@< ^:h6C8joH+tSgMG}.*nE+%C]/\ ڱ,_1Qwɚ[,fHȣ302- Rjzkx{6Gqn͹QZg⩋ ^-#,OYT'[lj= H2*N)ʱq#s{'2ʶ e)b;oՅ{"Zq8^/in̷ǃ^ bxd((Em(S[ S}?=QpMlA'Vvݶpz?.W4SWyhNm42}IZa[$Y/ȩ Gfԃ@#ZRec='bƊ-.%_N'ub-)xg⒮K)w85` TQ>EykQ7wKn5[I=rXw64L OlPtzn^.q/dm7e^b]Z X#.w=v@N 턮?ܱ$(qOoZ*ՒUI׾Ru_qK,*:'IM4>ބ;7-f" bXSK h%%y:_mb ƳbDzk<5epyT{&xZ~eaO)V?f^[hU y6>>(l'Eob̡.ࠝ8[,dJb^+^L7.M/sn;9;a;<Ł \p 1RjH?Q|AERޟͦ_)tkd}$l\> -7ˢ>B p=׶`u ca> f_Bve*Tk QrҮz2w;ц'NcI+mWWy3lS? -ߩj37mǸ{VSry&A}dv7?_{SN'IM?AXq3ܮm.y!A12ߥHEE)D@vAl6*LtBNI{[0> 9&w)d-'"n:vVXr].}J-#IjIYz`[@I1&p>6sxeRJ9ܨ g2}m RtG䓞gY@u17v]iצѰ!r=֜"R񒩑+]RV+E '~/MIq8Nou1Mz[ iet3pIu7Uk. &]$ױ2޶:yv'Xbo,x?!gdD_Y6(]}vg^9,Tܔ/2VBMIİ1QTWŻSƖswK*[;,^ (7NR=_Vj8`[,@ guq%0 FY7„4UuM$KinABk Wi5t$|nW;rb2(!.KK9-R/hlmUAf@0 [pאzbgJɻQjEzNhN{Sq̈́;u, v;M5.}oѨcN&*xY endstream endobj 78 0 obj << /Length1 1144 /Length2 1528 /Length3 0 /Length 2250 /Filter /FlateDecode >> stream xuSyQa"AXHx\dDg"B+1+|&WY#]AĆ#t rt&TA>Z4s:¢gBvP#X4L,SB ]3i̜!>@͝[q?,fδ6Ptw'alPXp+c62@gH4Lx`Ѹp;џb B;E`B !@5|SGa5 V ku^(o>H0fn_T06x)"o1WB;Blľ  îWALd3Ep?5wO-47˝dq\xӽsiiWsYw! 10uL 2)5,fμ87 `px.1"`P @7C0sN0aB0 Q̯4xf.=eςAp+P/AIg'ϐc0nYXm,Zn+t^fD6r)m`9o9L{c" j湥i0=gCT~Ф5EkcϝWFWO;T&#񺓛Qz|%1͏(u#%[҅S.x^Ѡ[ꨂJvU}E*&6޼d(۴dzt̬]ӣ뫻5S^ّX}Dkm60dx0t~zli^Kɚv󶞆{k'֩#%ILf=?x$6wjVurhu(237k<]iu4Mтָ'" ^&?S^PZo#fn=q-ޞ'IS 6Ɖg'v5+:+E-%F#/7삯O$1w_H\W8PAݓҨ@BT9>2hZJ?U7[qf*L&\꺪#oXl-Aih\Fѹw)}ʭDءx5{b 2+: M%w:~uxe[ؤ=j*/ާ z:V]q[e"Y)sa@&YDtd[~Lwp[:eMY1uX|ƹڪ~9qluL,a$+o[{$mr>[4|x~p7>Qi\XZT< 0\8e@<2}llDUޭ\Q=D-)p#1ve9k|U\3)J)}AؾގWuЉ<گ4kli3[}!FW7=81&A[%E R9etI犓%?Hd)g֍{}:drވ>~s@ҞhReQ? {#nq69WxKKԇn7r겜p=*VmI.xu$ #c|?M>ՙe:Y`{Yt2C eͺiۍ{6i8U捞5 K֭^]%+ ڍ#VE\~E"Pk~%lLs+ęyoj UVHF`iͶ8QO 6kKZ$M sSC] ąhv~B1Ja:`:>LcKRa-4&w([nR(UK}5*a㧬'R4>o R:`4V̷(2語rnxjo \s͓T҅ اPPhy`#qRãvEjA fR[SiNuC%eNy՝թsG9޷h{cdE>!Gm,)hi|-M7Q21dՈDZêhEm 쩒\h endstream endobj 80 0 obj << /Length1 1626 /Length2 11094 /Length3 0 /Length 11939 /Filter /FlateDecode >> stream xڭveTۖ-܂K(!8] (Nn݂;!C}sߟ~G%s͵{-&%$ qp Tn2 xJ̠`$YANN*-@ 4tLL0Ok+@89DM ANE r%XA\8, Zse}Œp\@4/3 vu}].f@!_^V 9@^#^}`jW x&-P3_]n5bWK^a^P3+ U:ٛy~srMhO=OlQ u[rpִֶ;+ V?nNs= vJh Y@% ;Y}"$oO]вn*f 7Ș9^ேJ1s{5Z{)@^G"h* ;+?`WYR Xٿo%zX8la 6bcH9M}^vEH\.wj<['L?ܚc[KĞRZ!3B#Du3;ֈkec[U::[S._IAFEnkac(KbE5BFnQyj*jZ­ ?a@(y;%ɓ4UXkǣ(jys+(IA/k"piPL"J}эh?,%KP)G`ŋbc|(>IZ(.8]e.H8\xK-R5}bJ8 ^YK{m]"BL:lpFYK Tdr #B^Pwc^#&;oFh!['ȂJN9MN9|7ڃ/W}PV/&~ tI$P;OhPuA&ψ8ٳcon p{ܝᔕLwfR I7Xx=6~eH޳&X(vVRD(\[V mO*+hlQ:Jc-ѳ~u\OFlZV9tX]Pga6Q3NM6:El)y=G:9mXqYK}f@S%\mIEk\VHh[%5W](o4m]!v Mjr@EZTy&E?'T|fk6:CКLKF~CAfU<- iIE_4ԅ?Y3Ee98xNi@ wlSfvSG*zZnU8MMU2O YfQz{tEg,H XI"l`cWN鄗.֭qkg&G+u޽"UF.PY8'R:-V:FLpE?`/Rf @V׫uW)!BT:gi}YzWp"|v5Ѵs=Uh-VPGJ4JEPZ GY tyWBy`!YrxBʢ8THGqv) TK._dtRۦ9\,xc6xxRIV#ߓ/kSۆl58Minyz٫CpIE1:ءatjӀW_ W92gMzqg٥'-| h8|jlӟX+W(_K͸hcWpE߱9-#^xw'L)ߵQ#B]n@ltu>?: Yf.͝덕T~0doӛΨG y鍲#.|05۟;؇\9/@'r2{,}0C?%g&W ٝB):%/dH gNOcť,5 .GKVSq0. 2R#?]}WgJ[q#&1y\iq& oJzT[xd¬ 8 wL'AXFF0 ~Æ\;,"e'Ew?i+ $L+.CΣi8 ҉u'qL"ֲbջY-*$`ٰF!r9PZCDZWѵǘ+5r̬ #"'xc-;1D;^(c,jkӇ;DneBSha6^@l".fP~%8 "do#E^DOM~sY./%S% %KLD Z/B -QaS:dڲ?R]B"{V/+c|`3ļ {r)fgbcIAoIv{Ωr\<۩#?f8s:S|ߨm+Ϡ(fĥ&:CFJlmm{ ;Qd5+dzw`-q*<Q6qq'F΅cVB,EPbwJYIbMƢ&u/L;fjRJ2QJ=rZ_`뢗ɨ LA$3D/|.F+x^8Ζ[ 45,_xܳ8ZbOPv]71KC+p!_sFZӃ<r$"]jLWf'&:i~7|99 =BE)W1AA&Cu#u˚e=tɔvMGZ~]<.oHAq[Bw3AZ"wO FneɄ Kx؃/ \Mc~[dkMquTRe4N)nxB[_%r`c!F"+ ,ld/OX"YX 5Cl=*9ss4r/PPmA=(&B!bR(z$.8q\X~@zj'xzrӄܘEw Mꃟ"+ʣxm*U} ^;G-L5O..Ӳ "Ows>rAs9M0FwG sXK}q;֓S-6ox6HN9n[|KΝ14lH#x Dmg6}v9Jw$T3)јc8*+djp;/ӵK6r!w\VݏׅaMƉoв؈F3!8roR2TSWoZxrYo6jЋrǶB'I ĽE+`$5k2 iwKzS$?,RgH}*-WѡQԕq`]E~#rxxQ!( 䍑]2"\)P{zjcYf ,e/8~AZ}Dž>n*wa oH'Ѻ]ͼVkZbiPX@J |8SIE5g3|ߜ2hrA`qA]ܩŵ+ C4+ dr2֎}ZPLGl?QI lQ(G7I/]7]U۽3ޙxĬRE6i( X)I<;߱D6na N{TyF6?>^a^ijRqp>=V`# zy>9|(PM`c0ΞZ711Ā,#u{t'Kvθ!i3xB~4cUL8 Z/1>E@Sdnաğ6࠮ͫ*ix@Kß jqd3(VU6]~aϳTwI#u 5$c%ƒuLI a5x, De8$4gdNSM6Cq.ziV;DG͚֟p_ ZS=Oqk L!(2lmkx|DXZj=ǧ HEMR1X^踟ocM]SwxZdګ,UOA''<ζ޳D?? wJBV"_$'Rk6& M~? v^c7X> r]eo[cZ Ɯ4=~f2mQR u6!,!8N1%?Ÿ˶l 8NLS:++oɹʛ+u5/G3EYkĔ& 3w\y &(tqIG뮘]{{g{DD22l1{@nzŐC-/C/W.aNdBH1S?g_]Z(L;۞oOnrsEb#-C+̴T7ԫ ۜdw뼢ux[ ;'0ϑ]r9T軏Gr:69?&2K\c|v605yٿ(\E!B{%]TڰKUpٽM7uS&mbuY.527Mq ޭW&i'~D?%;@vg]jzo )-%F!q} Vo֦Wxגp8J?w%Ƿس<[[!e3hGb&d?Y.oe|p5u@jkITOA!]ھ 1PjQ@vT1Gaavp6)ir˔tےNݜ2 2~(C`sCOvޗEtbX+\yqCyVllߞM!} ]&ڰ=!ζJƭ#oG`i}XaMڈ/פ(࿑,(T-> }w0ȳVi&dZ;U:C5oEDžo9xdpo`gy=!^ÀoRB-ۿ6ka.ikHHMw.D+TId?ԘeֶDKy"n]ILO. +wOGX6 ;尶Kh#Vθh{ӕmZ1q2a ䷹ ag]m&SW:<3)ך\DXv3)q /4\'!v ҟ 2's, IS16oӜp8e"JHgZԥ+-zHQL=( >Qʋ8OG)Z9(Ƹ@}>~bM)/zm&7-fR3уt!8oÞ?}4#`j/O}썈4[| Ziĵo7 Eʬ^'ɿ劌ƨELs-мnMlp?LH{:.x?R@USa%=*pNʹ݌ EXa@ qC6͟7Я+"OmŖ"PGtCUi|P!4WQ3adO.1`,1&B@ơv JL3=gAC~^1C6"J=\BGH,.n #z=;m5vRI^`b˭{.b<9:y?r4'5L bwC&oFݥ!ª*ȵh$)~bQɃIHPMbpZDF^qŪG!-im-ef+:O!%߾i)&awDaNeJeRUG\-3M2eʹax a/,"\%mfMH8MAQܩmJWJۣ_ҐKƮIQx{S(EZ*[G|nTn~c5[Yh00ag'GvR'<*s+OR-ȫif'_Clw&`ozwǯVnPNQ}A~E }&C# [t njcd:e[e:Nk2 JYGTە @4NFSR>x>uLHR'YTXKwr~ೣI=6c޵=O KJ$mYgp!2ǔQhVc0Đ@a0mq'cqJZ:>%kfcDLL_Is2ڧG=ְv`E -]o`aAJ}i@qdʃˍZ!ZżIsIlat>g&l7r?]ï> ;~C.d\Rn:]2]ǨF{^9ކRp^ ))JnZeoŬSxH bi<-=8\LVѥJCKţ#9&fIhg#2uKk7 CN0Xi^bT>ߛދSH qhNș)yj~M"(Y: EkH̠".c\jNM$r/~͉  Uޚ$UcF4Ki,ϥ|#GƺK+_s5XBQF7ム Cުޫk$hu Hb7q_ןLJ*['ٶu+S^pH"7^}] Ff4'\@K形aN2,4Zkaҍ v澞 Glv5lKW CN"L!!Y:T|ӄftÀrY%a(/?+E%Z'ÖY;E:"Km3'uA+?$ 1ѩ ;%1Ĕ8U&ΑS wh>{}q-0\_z'bĵѓB?3ORĽes,W=zX gD(v\@XXq}(ELfn% H~kpؾWfFuw,x%]HL#yvk shُtԍK2#Yؘ,<5ܧ+DhY6Uy~UgsJ\3& F 8V\wUem,0fLc=rETz{h Pߟ R^8}o0daBB"N9,קxA\$S}ؿ% 'BA@.zJ=a^YZÅfp}o@m;|f;nؕ70pUzawüSmSK?`,zrhXZeLZWsئAL 3jb#~[dD1BiX6:QstHsFQ慆5w-7Ƹ"~jLP+wb5!$5e9Y YtjyI> Ԙ5ÚJOXuƄoҦ>*H7~%K,nxj?c\:8 |5Qg ldKiK@qtZ? Vdžj]#|߹e:=Uzr[,u[h=e62v> stream xڬeP\m& [wwwwwwww'Cp/Ι3u?3Ǯkkݫz+ %lmx k#gG[k[n9z3௜\h3t4&11 Osw;T4iiS ?4=Af6/.@+[;k׎@ 0YJZ *I5$`hPr6@@G 5`Oi c ; v@c_71` rt9 m1r6_9LdUIL8 ؚ45vu28nN2L@vVs f gG"8 LOwNRme?1V ,s;mggVmLmL8Q33AXL NSXf#[#r\_CK8[Y)Z%chgrd?v2a010[rM@NSC=\`_m331ws?$[1_JIho wwG5&O[7'=3 _,or_?Oz%?dhcw_V=4_[5 HLwc +m^TWc]6i}@pˊ7xOMJ_EI{_~y(~7_mK٣qjC,fJ³sē?C#ýP9p伆>gIN??^\8Z5jP\=_~3_} 3 -ʺ^ İ%M~ѯZ>_XhI\!5E.KoS I -fjěH3q+kGr G W$ Gw:y|6X}D?f>rxcҲ9zyQ)gŇՄ%R1mQsd F09Uj7Uj˺'J:>YW'M=iA@l{㈖T2Y8<dwE&:J_I2lX(\S&B",bd~01Yh5x;#qtL#ĭcV|ަ7aD_}*]7")\\2r1I ރ=u6g]6R̋,njki@Vn/wuqn(Y͆ Ŷ%~a&oA 'p\d؟/n#P 6s*{v(vznA@7:WNnf ݯ7)*@x Ead0t:ȓbČ߅缤쭧n!9.F}o}(o`ɁΛbW8M<&xyxcAMlDIӂ u&H}/9ZYGlnدXJ5,C^)SL{PE͙75t(Pmir1b`s#8'$ @|!+9ҮRY4xfRdj,$'6+e&T LpvPƑ3tl+^  Fw`WagŭӒOƪ9 `B TX~W(p:'i#?ihn^ P=#phnk{Xy4GH80F̩Z SzHL_bѱ}z2ZeyI΁hfLNɝLT>5'c*^Hʽ~xi}|8zrI5Y \7g+q㉛|# dՇJH.t[]cS!Y$8Ü|F_GUUrl"MI: 4 \w>Ym[\Av`i7)Ę}L~V$~,خ<.W@Ak5YP\VXܚ i{A-VPsBO*V`C' i,&#{"GA|pn̫5^Oz0<^dѾB0Ԓz=S+'~ThT 'DknFb e&itqd^pŲ$&4~ E}V~cҜ2\1H$-;Br[BW$3O7r4Gh4ˆM1 i4Z" / B}bk/F6k™f5a9 % 2r'Vf}7$W3a/^i !d3s 7݂+;jO1葆,MSb,c[2d=t!í66aE .2e4LJTw֙w/rcoc3wF\^H4ۦ.{-SnQf4Mкqe,`*f[VA [\C5BDI[7NgG >^ԞF) jͮyx]ts O~wUH" y=cIv;5jMO,C6i9Sgq/br:`I_D6EzZ _-ź05UJg"ݙ;/eLc FFU:|[ySI= (־{x9N%|Y۔@%Fl *ZHD?ڡDa%:ﻕeKfDBCoStXʂla9T ,$1>vҧ޿˪Sz%Kn Db>nBM3k#:CTˀ.-&Vy=M=^/>{&{D[Ag糠' jviĔ(e3ԞW$e/{=H޳xϲx]_ qCVI6jгFne݌|VxS+r!bxYޛi [˃,׌KfЎ| ;$"@[5 y<>ױCFuBvn,!C{]pm9/AwVN9K\C}z;!!J"G>֍KiF TkE[7@Q,Cٳ<$r?G/ rGtQTxQ3DUY7jrE%60XH'ml WQ?/'q "{sBUlP}3_'tC>:Cl0.7s6%aIf$pM&0lqxuFp2,kZHg/XIѓ4>gi=QZ.䦥%D-VS;^MH' FnuCC)bTܴ<2zhJVKViqtXiEqK6Ixr6$ФxKF.%ő,m 7)gHB#g9C7UfPgt_-Zu Y- FEAA(-؈όw*%1i6wTo2қJ\Ȣ c[PEv 8 j{K;&߸mQ|{[Yać?yB%l0"iQI Lh1khf`hnVÛ :t֟8JbVq ]Qee"%ʩIce‚KuP{O0dq=%{DokzZtIbfYS~p`JNpCkX\c^HX.LֵVnK/̩*9aTž5%qq4JlH.)v*15%!Ӑ(pqMOCf^˖;/Vk1W0ٜ}6Jgh@uxwsy,0tሉ(:~ٕBբk=/kCE}Wl.}pE q>:!dzpCu7ڰV2S XUk;LܦO%;륂u8q[]sᛨŽ?SPpѲmIL:TC]TIC;.`,,݂@TgMH!x hD#9@+ʧXa5 4״zHu>b~@V=#"&<DŽ=xs`T>יtHi}w 碑8'w $.!#sj@c^ri s6\IJQz5gqG=[q3Coś;(ݟ6EJ 6"/IwjXŜ s_5'hR:$əY& E;Ѻ8bΉ4OnnZp፬%W݁dN?zS^8#K;zEnFȓ;U#\s[UsnuW( qޮQNa"Dh|(Y^oAʭL֥h1k oq'"ԏɝgpe40Mt䨰A+U`2ǾjwE}юHr=t|Z'?zE(gƌ'/ jdZE6;2́z^ڡZXU/N9缐'X<&f_NsT T (!@Xܙ}PmecN~[< .Qz-3RXߪL&[9U{ؗ|j>ʐAّ%оdzh"@~Z\%d!F`_令6nxok>l.c00mMiN r$}BMȣߜNqG$M+5J%Sqb!SP+.Րh#cd+ 2=K~+4;F'(ixmt!§ #}TZ (~)@<ҌTZ{gu:_?2#Rv[q/*%4֊}M_XŹL}FnxN1=">0ڣv!fH45I{-vŽĬT7m^(2B2ʊ$X-p6b|.GyAP܀0PY(;0*2$|#x-Qĉk2\O`gCEOF P&@"SQsH?^1m'rn!D2)2 ٬ţ1'-i;O&>WcTDv HH&{rk-S$B9r! >o_{Q)I*-5ibPJN\~֡)wW$Ҡ  6hCP' Erb,<Bt8gXdtt#%&GҹQ"6Ql ,}hXrtO;T:$X &DA6%"qj)+B[ոg,*9夦"}M&2LN:ahQ%1B6Z܆@-M﵆'sr>mP3:؄ZS5C:Jt~JlDd]%Ai2 mq%-e0#U|Ȁ}['d,raϢ:-퐢uo|x Ćק$a8HC f>8/(r|.ryiMpf)J Saע?rmQҀWA!weo =$:,;:gi7+2ETFƘݣ=)V#ڟh,,PH| Lk$H2ϛx.>R5ɷ6R&4Ȁu!%"E^Wn_x7]=YWGl8jY8:Q44qbfɄAk2ʈ@n~V zޒdV SRBV[E4)ҭl!F nyJFLrdPg[c KeNFJ>DEbIXT*˚pN7R{O ?ge=l"MEAVW[I,/\{3LfW( ^OpYYB =&xAaF`!$>n}F'e <{e+U+^L*Ť%*Img:FQ宅,XH-"4AxBM]knaRP䫖+()Ƚէ{RF+VGLx`*+\ц#'hU U.\ E EZ!񵲒)O 0G X_a;ɶq =KL^'RiI?jƏ=q,[5R"7FU'i#sy.Ok^3tos.r`9#:^NUhvwHbYJ1eyeŝp7ҜUI=-q jb 1R⸣4;} %v׶/pLi<3zT]w+6@SdT)Ȳ4JW;7{c:|5\C4I0>UԙN +'?W۾04׃Q>>u#sŮ [x5x3e%Ք|x.d:f(Bp󋉩ׯHG1z*ڽҿW "|ZR)^:cwϞ33f9Hв#YB_2Vrt-?uӾ!H. PfUqG{a|"_mر -e2K6W.`ơ-NL!ƻc|S 른&7T#H]:NSņ ATR.KV'[ mtSEXhvv b'YŻIGr5!f?u MsxNh"P(S!BLa!yWPP+vϋ LRQgmm-X/0a)4<ݩa+Ap̡;J7(`R sV{w皪<OՖFﱗu:1G}5Ѽ9M;~I&ďca Ihf4JƋ%tiɥ{7} *OUkԼq2jXT,0]`REyZj }G[V))Zy( 55`h.'~^_ %{y4\ڷIyaAJP{@m -9_PR8Q-lR>P^6A\8!pA_\E2UE Krx]\RI3ٶm@w5njډG$GA2iq7pPBFB~ϡ&M*D>\!ߙ-3Ug $zIqZ(8k=O[mаX}`bs39BJs Vn,:4ƅح^5ƞ$èf |Ʊr[IaL3˔'YޟDeĒ8$`0lx+ce۪_Ҿa^9a(:;#0ϟ4KAC'}"83 3?`5N Kf@zz;!A5SVj + njԓfUHXn6c̶/0ۺ# fXݬL@J.E6'¹8bbU8mc50/~~Mv4Tb%b8R~u$}F|.! Fʤ%<+N -0a|rJdDA<\G5POœ<4HmL*t}|4 MKfY]Kt'F?`5|Vw:G[]uG`r‚y%K_=m:Qý2ax1z eF,(s ["E3}&_3>[\`Z}ovzJIE[`o0ԨͫoSv\ld ?=%A)chmr||cyj )0p͕B(OFr7Xin P7M)֒0Cl!Iԋ={(t%Y^z8}7V=ߞ|˩]= l#i]fbh, OׯlM @-z ;e+ޱQt( UD]b6~k`9L"0Ը: 8W[Y?n)+'R5ty}Д}BkuTV:}t7?!|<ԽucVNo҄}C7kojO+K|5RtwoXXK!Zy b>Du5. 7Wn3ȓIa"y%u/dW dž*_ f9qU޴_S{=-e:f39G,`9PFKhcl4ȉHWDȟ)JgH~~)$$Mb}efrjkMq}-YgXOTQF`}A. BJhAR %d<Y7Jw."E8⎾SCNBaEO?U )>w NN)52W#- Cj?6E:`IȀ v!(֐yk]3n1fW2ъW҈(;*ZN}DIhzo, |H$(=i#ǡJ3qno ͬ:$Jf(%qp߮3kGazFQ\p:-:V<0!|5]A@.>A=1[(ؕg\zb%FNɱT<ʴ&n1SL/EyYqG(7CiKxKgm5:Mx;JDP:T6yQ4LV@m9-YE~̈m5*0oJAVo%bVCuD~HN`{q1R{9B&n eSF5jcz^z5KbU@$yX'D g+tXlu4#ՉF0&zB^ ?S16;8{tEӅ',K/͌]PoWwPK‿e ۪2ݢ뱛59}ŭ kǕku m!1}5)O<2tO;Fm sӦŚ\T`86bq$>]NGCG%fmk݌ %pf])?zPd6&D<܃$q>2WѴJʘ%qP U'4MxQz \OɃ JڂAcMYYƍ WɌQCfՆf aA3Ͱ {2s;)Iatyn7U^n#+r8|:aT{= )sEpRKfػ㉛Jb.%;3םtf`Ftt[b.Dz]*Z 2{5Aӏ5"[Iމָ# *ˑHi.k]>gaS/i) 4$07EtxMQx}#1}32ˁڐif0d$8?U d-?8ry9OMQBm>F}3cZjҎ=]-[@P2vypݿDc )oד=5-W>(U*_tk*i`s#=#sd$ӺU2 &yW+*4o I1ZU%jmPd@ 1 L) 2R+TK Nt"yʰABۢ\@N4j7xIN 3]hhǪ.j_Q!UicW'DKwZ՟iiBAB8Sܤ3n8ƾ$SgR0ciWf*B|uؒI \^XEG]Hѹ K~y`^吱rsLuIL Rfm#u.nŲk+6vSW?J/,/RLP* )FTRlTy>[ ?/(O'y-/?MIloa},6jt9_6ۼAA]O_]g9PzaKw}|QQ[y(!@RŦFa؁` d^C'S^cxX $">>y P}mS5@3gPTd҅IkkaǢef SSa!4)A)Py@<N&Ȕ3#`#aĴ ㋋VKǝ3B2 ?BT=9A>2k.o*|_ZAT&8V)^Ȕ1VڟϙSm#&|ŠIA8xȼU#(EHwtaV,vt A;AIr߭ۆNt.R0y">} 1o(ۦrDVagTO\DJ[S+=-Ybb%T-h8 w;`[)I G,l)SC$2z.+o: L0ۿ  4 *g;#_ML2%zZ4#C !hPri +eĎJ&oL-c Ewf,gLldL9 ?4S~okmm<{ ֆT!Q̽`*#j %{s%0 $m{Co>*\~JC\O}C,9o\2*fr.<`ʕ͏&[a B9/!፜D/>'hyV#QCjf핹tҚkp d!JMz0LM7HO0dtj)*A 2 ū}l#Mm>\(@5C ѕ}ۏA~J?`t?mrjShxJ:ZP=n_?#6C\hdt0WXـ-JVo2֚[q̏oْ5HqPgػ9+:~,W,J 6F갚ʭJ7|MQ}5ox?-LL4yv|5aB|@wO _; rꙫUu@0jw9@@0 p>xH:x?  tt u}8d-kHqQa~pgWۈr_կy%[}@6487)ٺRyL=$Kb\/l Lc^Mi}G7\7)I7.>f&g:?@܀BZSc5ix@O x); p_[Y=ƍb:ٴ$Gs;֦@-ӉRi6{O O"K_^5s/ƠT8NnM-uBl̵y ,q$u'$jK O%csYNOSl,;:*$m,ZhyR#.P8bpʾz2zj&M15+Jt-Y.pq$L#g F87PC1zϙ}W  nMeTwo?kl-IZr9b]+$9.1z]wwTJ/ ̬B{!*:TtT21F RdmB+Kb#UTn6V^+[Ră#$kd-̄ B.p'h83#V":U8(4d$È:P=YӗDs|-"Q]ơ0XQ(/8r^SVbРXj:iT ?Y+͝ ixF8FJ'%(h39{jINFAHew#iGTzhvVqvŁsq^* gq%AjpRsT~/ +O4?^lAe6ҍrtÄ ,,x6J \.vb ZǏxgYqO}c+tڏ42x9䍦0M^ֱkv"0oIvsQzM]IݷL2\,%|W%sl9cIőt ;aCWo?+gO:3ؓ6*̖t_m6J_2*l8.0HSV\ +eOH)p%U5B \/6*CK-Vk̋MQ B}YN2 T):d_m3o+F1};2D4=yUr)ctrp VQjGFLHv^s n+wY7;f`~Wztrw4O9܅idq%YWa3qViz@e{E"3&LjP|aˌ )Ԯf(Wǡ#C#QM`a.Nڌa=3>'iqqԃ%lΝz-rgJeӎHڸtҊt:W ~Ckp#J-c_NNIVl+2u6<{Z@`t0h?NѢ+襱,`#ף*,XhS%aʹ_\bmڊ'&fOl[Xu!M% -|,Tt6Z&K7B=)rqAfS5PympŸFi[#DA6ҵt02?~᷐*XT ΅SLp5>a 4"3911N;vk'۵)iZܚG)2a(cu6#"YG2^Ґo4<=1x*yj9$X*twa**] s,53 k|tPp/-M%ZGʡmÚi Y +P{ҋ6g~~7,4 -1{/2jBŨ "F7#/*K%Zm]x}މ80F:h3笿ۗ0wd"U0ɹ'`?+zm2J/ͺi {WBK0UsN}g~KkYV 7VjSzo7 %ᬦ|B_0Wo` Uj3ŠYlF y r];P;EUHO \-Rd0A{G)R_Fq^$6SpL"DUc6w ɏ:TTQTSVHIܖ=3Ho1󱳩b$O g9sH1/:t98OmۗuJQv8N`x91{rtӶ1'5ydy[@8YaiqHt lORf7?}y}@c疽;+3GZā_Cxl|y8C¼ KaD56rpv  Km;}%9q)O/.¢EiUea[9Pv B;!DR`UIԂQۺ%w7U_F'\~xx7n73y8 =G 3ƹi6V\]=^붼ez:+/Gk .9FDX>W^?>.G~H}g}WhGt_bJ;qGE:2z{x]~$c.3*'×_:r-Hct9[6SQ55є߁TR.83z(8-N\SpG!3mpWyC,N *%[nuxiYٻC8)7w<%=\ؕC9WmɁsރJAG/V Hu [ؙ/ 4}>f@QH׎n(vn69/0XR8o 0sx-!7/cvknn̘˟Q8-rf2IE.JXZ)d!AiJc51HL}q<嬾շSbQiFd/:TC7Y27]G״`.*ye*oYOJB4ސ;| /sjY(Gkyb e4$z~Va6IKDexee3GdyqU%zu96U(!*6Q uhU䪛sa cvZ1wPSr~2a;ڍu!*54"|ΊR#:[iUf<IPf}X joyY7uyU %6!3Jx\2H~3UL}2oGjx=/5cd&\0|gռ͐Ry~^\?<g'|@=l1Ծ*j~q&͘dpurLIUʕ_B˞ _B]oTTg~$ "aLc4fn˧nfx)z~;e&*9Ȭ;*j}.57?{w& U'QEA{F̰Pk.ޣGwM'q}y%=bVK4jO~JʕaGP'1ӧMخTs96"VpT#[ۣv M$hKH5o%ʒr9JmƼeFF/kr3Bo[<6:4X.3݃G~ѕ~r&@0ǥ,Xe'RGȰhk$QB7$KdWEBapJZ]J%@wY1mn)IqJ@oOh~w!)Fr G!]MKA†IsB^Thz0K5,+w& 0v]0^bOj Rj0 %Ǻ[4798V sh~L7Y ( 6Uݝj(%g#ZK#GexWWF $!!P@7 :K%q`:wwJAXQ~n4A+2-՜pmȎx}#L`ޯ9_:~&Γb3)ձŞDaQջ,tk;WRwiH.v].>0.,WR‘ 7qPEq{|*adH\ukNkM,+{XLi>)u͊]~[?\-7xSUmZ nZ:t;nL[@ KK3jsO6^yߢM\ڰBMhҕ3񕾝 ˾/ׯxpt̳׬\qzo4GpY2,Bby2r'x)81\~hjƒ !T^ SXpRuLx5fup[5vNzXeY(Yr)LvC~:vg<|RD{tn>nn8X 5 w xaoDEHo'r<'0m ?5Dlbwα oy)l\ Xz,&EEliڱ'mvO4Idd+d'P/BA0aa ]YG7`ۍ& L_-Lv҂3AY~:VĐd0X8PS!l#Xjݦ}^O}7xGiق!v!0,fC^B{DhQ#BDYd#~6Eb!#Q0 h rpnCO&/D uY&E):0ސ.҂)Rs@ _f\r+])Jخx\.uC (%\~&YaHS#T"}syĖD eGgBz$*F)W-EWV:V;^V 5:QlXJ6?i̳)Q )V,%a"y-\,  +ŦNb:]թ`dD9*oؐ<6Y{qO>6b2Bf5xzqf޷tf,JJ{试"yl뿟5NeYF7*tN:z9$/:5?6>iLV 7,{U|LRj+*]MOB} )ulG' D%>|*9S%չ>GsU0,Z; F; endstream endobj 86 0 obj << /Length1 1647 /Length2 11959 /Length3 0 /Length 12814 /Filter /FlateDecode >> stream xڭvcxݲmccضtضmcÎmcfg}}sFUQޗXQN(ngLD 1rqR㒥SH9Z>168rrG34&...8r3JMY+ ,myt0P|>mΟcG lZX" R* y5Y1@h 0sXc054'O.!'!hlt7쁎6NN '8,l]LJnjwBv;l>O2E;'g'cG {ggTEQlnWl'O`g寒>i>QgC ['3XF@gO2{Gpq5WG5WRv,֦pL̟1?cY1/Rv&M\> zg&v)gHLe=$_E?q]rSX[|6? s>g @װ6t5p,/WC kwp;Bf 1ѳl$n4Qp66Zv5[-SӉ0Us c+ۿ`5>uE%o4ʹ{gW8zI]?Q ۹عt:r1?M;@ ߿VF#fklgW8ښ|]?{|Vߗtí,[ge8bMj0ؗ6uosUo~oX8ۗ>N^~-@٠h9d+E8S%`gBIY`?k?:٣=qZ}Fr#jmE#` d>MN,9!o)q};+ Zƛ i-IHofһ)4FFϫ{s>R@~k&wx-iq5~FMiNW TDoq*s)[RvK-'EB=6溦dy%V;s/[_Ju*oTـ04 #[oB-ok0/ dh=Su Nkwܢ?7l^-vY0wD>pȜp˴嶏Ne:;)TB,L^vv!-9Cc^JHҨ)aсޚ{%zq|bT97D.\_Tc SWӨM*˯Qʂ^SSrKQҾE7Hy1D46Ս"DMrd `裟t:`ZX[IKjd]2x.?d18|VӍ۲ׄNO@EmaLr=?THj/8I.yZ(w*Mu;RBSpH4 gID~Edp"(лS$cɐ2q "Dh%7nƳ'2U<Oβf4D!AΣꇃ9:?2E ~vfnw &gg9[[{i]V mM2]o!/ ]- -j%I .0]Ť79L6z.d̟ TuM[u<UjYx@xx9,X_Kf]R߷?.ɋt9Ԋe#S]~: uTEM{;;<83ǗhA(y̷1;+L΋m<^IgNɢc*]&O-Zܿ]2'ʘd{L 2.f=ABTYPxjZed|rx!N̫P0j~E4'>ӻ\=Y&JC1 :Iuq kjah 1^hX[ھ6*4ųl/Gǭ0g C` )KӇ}u8+wMxwB5۫MyoUJ;2bGW+a[U6O3E+`}:`b&X)e^Pomޞ(aѲk wC"Cij7^Jgy @3y֦qj/\D#`q&wKRm؞`Vnגp0޲z(j|Yt3>%J:˻)eo2ÆeD}A'~烤bn?>Hn87w6W VKf9oy1aTL'R')z!5[J:FX2/ccd:;3Ql@HxſȞ)`+ :ʃr.s rѬ&H:;Ϋ˜h49#RO婪>C׌hm1yw`n`2܌{}GRYIK<*=5-( Ƥr{ڒ<t|(K!_ꀴgqL1{n߇V7NF9:@~E?H~xMl9ݐX( ThZ#qkҧ _b'RQdn.<+uF+3_;?*TJ(KPOT3{MF:¾>(XR3^r^V E6͕ (xOdؠx)>TL7~/aO_`,aa*IK' i;\a@^_OKL=LKN;uڹiF6eaGȝC@NlTP_)c2ZlM>l.^[:C̗RFDbjx@P_`*L${%(?1!#]U)S܂<)m´5q0jsqP귖2xW7xy2yA2D>5Cq}y-+OD";%)!V^]#ZJw5NArɮg*[EI<5QA]GZL2:&nH)rd!9. BISK8زx jP$`EukwRʪYn@fgJΜؑa!o-jؑdS?rP祵1w6cL~,&ׅN'ղ]C0OYF Z6f1l#\/IbDϟLq28jj,&µagAv5FيHR'dž74nojdLU ʂ7m]JG6Řs%(WJ(w OyG Z@3TVS@.(1VY=X2< j\*`[H/DJe;G4񒷥y?Q ھ~$R}vDKL̾Exv.0!=[j@W3x-fj.ᒫ5տ&zD|*l`UOZ8̝'AGK5ʨ *hd@l enyRIgo8S>ّ:Axա>گm#teݨ6+*6Kk/}T80u*xK1huf# B曥Ѷ&F;PfѳvKI2=$frVo*A7 *P4&'\ה0_dsr̂bl'((BF~[@^^<@(k; xSz97!1ݲ?r~̌^($[p (+IXL0rtg䏣3_6) ˅=yn`7,9n.ȀE+亏sٴ4¦[4ZLD%C6'OM^34C -ԇN[*Z밆895ڝl D}FāO._+ఏz%0G3ut;<۾݉гL ?x!J+c/^R18<iqYDC*.-A\º5%O5&pFH(8}˓G|;r 98T{ZKTTpE[X K  s 8ET;Z_odN{V:s|E"'jK_?Kx1XSaθIwh 2KOs?A°O>Ϟ쐅/T#.L:MQre IXڿkb.Z7C6JЛ;yoUK08wu+S9:SQ\A=QYeq/SaM`B聯[˛/Qor;Zh_ǝVڗGIwv#]BO.0]9|;-^)T g5R`w)."EK1nq^ ?PPZ? W L_ʐ>v,Vl@cHB4Q@I4-n%XEt_MeJ̢ΣF(7?!4.T*j{F?ql3=ޙ07!\C%jaVQٱmavINU J͉[%0h[6ʮŒ۬o8ZHЖhd->l\)'$x{uy&ؘܡ\{LК?%h1Ü2܄~u-=PmaBKew_IuglUG%ȠL{ UC<)d0ĚHxA\2[1u&$LFݺxl8*|mI.4v!><5z3_ 8p Db0%U 0S*s)J1#aϤ aQԼٝu5bZXb} ŸR̻*;KZ/CgChukȌAI|M@m5m TE{mP%-={{t(EqXʜD!F۹qE;D_qD崿5ǐi须 Xj 5xwmdkSQ46FXtG\ I>Dt[aGa^1H /%_N\FD:\a𚖰:4*:[3):1 s+4d}-;)ݚBw w6vB;bMvOAð\Ƿ-[_|h;H,l}B(aJr%5$Y*v~l$W ~,רQn AΩ9-t/p˂:S0LZ5q8i]#ۃTl-ˌR֨ p4a>$e .h[3gNPaGmA$fԚJK 86Lť<,Ky)e;C8[gB5\ 1ep+XǹڴG;kNݠ HD uV1=XOi_<Ϙ;"/XKoL84H4,F2>2Bdb="98`x4(2@<(,H庱|pMl J#TA>A8g2YO<+2מ#䢿A 2(AtI %e7RDIJhN=j=} 7-L!0 ҟȤ |a> /SDZ2e4]K̨FkVYlEtKZ"s7&kgd,͢|ůDpzd@$% JY&RȢܲwP*;+kz_gWTxS_Z)im䣯%L S:<_eQiXYU nzy?X72?pBLN_@m([`&^l@A|YB,]nC^NؾRDYqkUiqj*>;gpUQᔠH،h-ΐPBfl];^Mq0XyFUax? RUԇ(x] iw{Ț? 5C,%0Ԉ+A4VJ׏q'|Xeg,lC\5GÔ&'9/a 9S덹_CzFp*6 v}%G4=wB?*7k&W Ry.zœ{2BQPKJ k\/ϰ@χIP矗/UBߘjy^Ea\_7,s3l>mLp<\=MU٣@\p\q46d\\.CfSq ~)FPw}.Zix#700i;.]-.8 ΧGMCJL|gbOIa"c>@U[V%9B(o|$ 2k>'̭ǃإ2  xǕFX .*f/s#:Om?/Ula'tЕQ\ύL/o|8YC_-CGC{USc"6~I[lC"fN gb.ltZw5J9(A OP,6~ZzoƦ7\*wI n>\T2gfK]#;abܵ'_Pї#MLXQ9תs ]!$sʘsŊzGRf*c"&vm.nQ8ejjKj=jt˨huφNIzM ~ZzfuƉ=V߼ZwlUxK3pg 2"gC{"kI?-w>~ۯոmMV&l ȫ&٤)<ӑD˯`q%<#ogOzTQCe#01Ifyv&һNE _R[Zhh=S~g!-%Ze&l+2UC+74i9;2SM%*'9\u9Za??.MP*T)4bh0MJ$G#=]OgnyABf%VM}4p?*W"\ǐŵf i0 *wDؒY?t䨚h;-݇UO޲h<Θk>g7"V=4 tO_H8kNvX#pO,$.-2)qcNb$̸9 )F|.cqo_Ys0\ֲoz3#)ЦU._q0 u>SXV2-,ys-n.g7kb؟tTXX_bw/*e..+ #<ВXK2Ⱥrx1_!64yc b]o.L\RtDC=V:l]H720MPpx&}Rw.W ;ȭ֯5?L)wシ-Q[>ZM~,ģ;Jq$4㧜|"2pgOV)VJʻ ^P2eݮ磲FGz}y(Vǖ7SlEr/z}5;# fq׃`Ga]wdn_&=|Q -܈13i3Vid79!Տ.]r\m%khhq՛oHV$xͅ+I|w #Ѧ;oA{1<gJȻ#$t!_Lᾝ[/P5էZe{*l7+ۼ,Tuw@'Ah2B=PG1*MMW C&.&/I.Rɨ%c1 d6L^P|*%mq; C]VBN3t*/tмKNH'})y( 5S׵ 7&!r`SEWct_Z4|pٞC=bPֵ|eZ٫r??V%| mCoʦ,=]-2UklEf*3Pʝ4m.| +xDdIMYTdd/bѕ IaO5IT/݊>+m2vZ.YНR3kq^za9Uh \d1DPY*]̚o1f LΖ[q\ʄB\Z5=vz] +ĺ$ ;VWqH= v`(KZD>kZaMLX 6Z,#gC$6EDAPn&;s:XIQEZ>gs"O%$n:+d"?Vf9h=B>a^A{:h.-]pҖ2 :Zg&2YӐlƘKE^uB(PA+WWVԃXc3me~TX ?ꐻ̧:rv:jrA 2ۆEzc|4hd/Ԅn| endstream endobj 95 0 obj << /Author()/Title()/Subject()/Creator(LaTeX with hyperref package)/Producer(pdfTeX-1.40.18)/Keywords() /CreationDate (D:20180922151505+01'00') /ModDate (D:20180922151505+01'00') /Trapped /False /PTEX.Fullbanner (This is pdfTeX, Version 3.14159265-2.6-1.40.18 (TeX Live 2017/W32TeX) kpathsea version 6.2.3) >> endobj 2 0 obj << /Type /ObjStm /N 79 /First 616 /Length 3364 /Filter /FlateDecode >> stream xZ[s6~ׯc܎ F;8q8q.4dzȴ͍,"@Jr$A\P,e2f3H5.&ńƛd2Cb:EMbYf2ᙔ,2Ŭì7LZ(sNaN2tV02 Ar"M QeRh;E.ehlcxA[i1xj g< jR֑LKCU<6@13HA I`V,@  8;p9|@ )0@VC(=tr)xF`^XhB>OtgFނ,=0KX"5ԇ\5YiC}On"'3*AҠ'P0B >d'7SكIr|~3}zU>˰Jbx'bAL۴,UL/IZw9%S8sʎ?(3{p~3c'U $?l䴡E~^ MӔƛ^Üg3`ޛL8q60T~r GӀ?Y`?>UԤY2"A%)F4naY{24FsGu^/৉_ZD ܎gkH5 EIlZtN+}hDlTi"@_ "_M9Fq$$U[)MG'9K^ЩtۂNb:]ё٘;P!K8UUiLg\ n670fxfΚRbn%>$pt+MАa"WBkPm碎jHD_?넞*s;'&]di6eJ 6BJMFn"!y9UD]4ҹMҺb~lb8YWT -T3k%43)%e^ӝ5$WZ')=u~Nc[Zb]AKgL2ڨ eo'wbʐziDIkÉd>A<&+I^=M)uKFcD0:vLh)C ;EaAeݱ@7iWV^,E3~(ЩY^س$c;Owdl5 .JS dJWlz`U"4)kTmؚIQ2RJ4ա+Ƅvi:@ 30>aY"fS&1D|"Aj2Epk [K,]ў5DdcG"y0@'8Ц6A\Jq$!c4`gE5N:ƢVFwRZߴH.VwhF$΀/$?#J?jzK>gPHt?E5eZ:KejoۀLAn W(VT${S+neD;jkEfAY&3Kڨg+]/#AjNF~[E| pEoQmBŴs+‚dYkpÓ>`r2uk-ۦoG?¼d'.RFE5l# jjck \}5ß5#&DMe˒_ O~Cq~QեY&sm^3^2 /W9~[~;VMg9gӝZfwΖk-?y~x/^t%XR T?S1+ Dl#O6:=}v/NvJHXqO9V26Fg?2>of_KǷeG+VGZ(݃RvR&zMӋ#hr:Iv}~/ QbtV!0U.&=3m>;wa)]e`Ft\$EtG  }@*zX~435I_[O/`2*Aj3XZ*r{X0x8_l]('V^{B}p,$)uV^3c.\/%8q$>6XrU4uG^-S̏XadqqcTTBDLW@mhd<(BՂ8 b$DK G,KxiiJ\¬⇘㌂P{SFh3x Oi#/y~ l#u[ף Bylxg-r3U"\  ?i "z.Ϋf#w1Q,xgm)zUV,RlϺq6}Δ嬶_x>Zps^pNF2K#DָGtokZwsKި|rZT$[1a"=@O8{p1j='RNWdڇ^^PAՓ.[3 %,y9?֜wM$n1f5DfP9WTXɴDXs9<>gg'i^҉>&ݓj8v,4tu@lvݡي΃Q,NV~T\UO9Y_hdrb/eb}G4R@'mN)h-טlIy١#a:ޭ;tT*%&} |=wjxO/up5pWG^/9[xuOptZa_.; endstream endobj 96 0 obj << /Type /XRef /Index [0 97] /Size 97 /W [1 3 1] /Root 94 0 R /Info 95 0 R /ID [<50B1931FCA95B34B73F159AE73761296> <50B1931FCA95B34B73F159AE73761296>] /Length 235 /Filter /FlateDecode >> stream xѧRD@I%[ 8  ϜjxTLH Rpt!@)$ !k)P U۰հ 5i@-CC4B+Y8]hfXUX XhhR>%ae1w2a]GI1j*lԌ5kDكQm>j~.F- Å+(K endstream endobj startxref 118621 %%EOF Rdpack/inst/examples/journal_with_percents.bib0000644000175000017500000000047713501141722021475 0ustar nileshnilesh@article{journalWithPercents, title = {Dummy example of {Journal} containing text with percents}, volume = {1}, journal = {Example bibtex file, https://github.com/GeoBosh/Rdpack/blob/master/inst/examples/journal%20with%20percents.bib}, author = {Boshnakov, Georgi N.}, year = {2018}, pages = {1--1} } Rdpack/inst/examples/tz.Rd0000644000175000017500000000171113501141722015323 0ustar nileshnilesh\name{dummyfun} \alias{a1} \alias{a2} \alias{a3} #ifdef windows \alias{onlywin} #endif #ifdef unix \alias{onlyunix} #endif \title{Example in Rdpack} \description{Dummy description. Second sentence. } \usage{dummyfun(x, y, type, flag = FALSE)} \arguments{ \item{x}{Description of \code{x}} \item{y}{Description of \code{y}} \item{type}{Description of \code{type}} \item{flag}{Description of \code{flag}} } \details{Dummy details. More dummy details. #ifdef unix These are on unix. #endif #ifdef windows These are on windows. #endif } \value{A list with the following components: \item{res}{result, a number} \item{convergence}{numeric code indicating convergence.} } \section{Further information}{ This is a user defined section. } \examples{ dummyfun(1) #ifdef windows ## example on Windows #endif #ifdef unix \dontrun{ ## need to supply a suitable file path (if any) for your system ## example on unix } #endif } \keyword{kw1} \keyword{kw2} Rdpack/inst/examples/reprompt.Rd0000644000175000017500000003617313646061720016561 0ustar nileshnilesh\name{reprompt} \alias{reprompt} \title{Update the documentation of a topic} \description{Examine the documentation of functions, methods or classes and update it with additional arguments, aliases, methods or slots, as appropriate. This is an extention of the promptXXX() family of functions. } \usage{ reprompt(object, infile = NULL, Rdtext = NULL, final = TRUE, type = NULL, package = NULL, methods = NULL, verbose = TRUE, filename = NULL, sec_copy = TRUE, edit = FALSE, \dots) } \arguments{ \item{object}{the object whose documentation is to be updated, such as a string, a function, a help topic, a parsed Rd object, see `Details'.} \item{infile}{a file name containing Rd documentation, see `Details'.} \item{Rdtext}{a character string with Rd formatted text, see `Details'.} \item{final}{logical, if \code{TRUE} modifies the output of \code{prompt} so that the package can be built.} \item{type}{type of topic, such as \code{"methods"} or \code{"class"}, see `Details'.} \item{package}{package name; document only objects defined in this package, especially useful for methods, see `Details'.} \item{methods}{ used for documentation of S4 methods only, rarely needed even for them. This argument is passed on to \code{\link[methods]{promptMethods}}, see its documentation for details. } \item{verbose}{if \code{TRUE} print messages on the screen.} \item{filename}{name of the file for the generated Rd content; if \code{NULL}, a suitable file name is generated, if \code{TRUE} it will be set to \code{infile}, if \code{FALSE} the Rd text is returned, see `Details'.} \item{\dots}{currently not used.} \item{sec_copy}{if \code{TRUE} copy Rd contents of unchanged sections in the result, see Details.} \item{edit}{if \code{TRUE} call \code{file.edit} just before returning. This argument is ignored if \code{filename} is \code{FALSE}.} } \details{ The typical use of \code{reprompt} is with one argument, as in \preformatted{ reprompt(infile = "./Rdpack/man/reprompt.Rd") reprompt(reprompt) reprompt("reprompt") } \code{reprompt} updates the requested documentation and writes the new Rd file in the current working directory. When argument \code{infile} is used, the descriptions of all objects described in the input file are updated. When an object or its name is given, \code{reprompt} looks first for installed documentation and processes it in the same way as in the case of \code{infile}. If there is no documentation for the object, \code{reprompt} creates a skeleton Rd file similar to the one produced by the base R functions from the \code{prompt} family (if \code{final = TRUE}, the default, it modifies the output of \code{prompt()}, so that the package can be built). To document a function, say \code{myfun}, in an existing Rd file, just add \code{myfun()} to the usage section in the file and call \code{reprompt()} on that file. Put quotes around the function name if it is non-syntactic. For replacement functions (functions with names ending in \code{<-}) \code{reprompt()} will insert the proper usage statement. For example, if the signature of \code{xxx<-} is \code{(x, ..., value)} then both, \code{"xxx<-"()} and \code{xxx() <- value} will be replaced by \code{xxx(x, ...) <- value}. For S4 methods and classes the argument "package" is often needed to restrict the output to methods defined in the package of interest. \preformatted{ reprompt("myfun-methods") reprompt("[<--methods", package = "mypackage") reprompt("[<-", type = "methods", package = "mypackage") # same reprompt("myclass", type = "class", package = "mypackage") reprompt("myclass-class", package = "mypackage") # same } Without the "package" argument the reprompt for \code{"[<-"} would give all methods defined by loaded packages at the time of the call. Currently \code{reprompt} functionality is not implemented for topic "package" but if \code{object} has the form "name-package" (or the equivalent with argument \code{topic}) and there is no documentation for \code{package?name}, \code{reprompt} calls \code{\link{promptPackageSexpr}} to create the required shell. Note that the shell produced by \code{promptPackageSexpr} does not need `reprompting' since the automatically generated information is included by \verb{\Sexpr}'s, not literal strings. Below are the details. Typically, only one of \code{object}, \code{infile}, and \code{Rdtext} is supplied. Warning messages are issued if this is not the case. The object must have been made available by the time when \code{reprompt()} is issued. If the object is in a package this is typically achieved by a \code{library()} command. \code{object} may be a function or a name, as accepted by the \code{?} operator. If it has the form "name-class" and "name-methods" a documentation shell for class "name" or the methods for generic function "name" will be examined/created. Alternatively, argument \code{type} may be set to "class" or "methods" to achieve the same effect. \code{infile} specifies a documentation file to be updated. If it contains the documentation for one or more functions, \code{reprompt} examines their usage statements and updates them if they have changed. It also adds arguments to the "arguments" section if not all arguments in the usage statements have entries there. If \code{infile} describes the methods of a function or a class, the checks made are as appropriate for them. For example, new methods and/or slots are added to the corresponding sections. It is all too easy in interactive use to forget to name the \code{infile} argument, compare\cr \code{reprompt("./man/reprompt.Rd")} vs. \code{reprompt(infile = "./man/reprompt.Rd")}).\cr A convenience feature is that if \code{infile} is missing and \code{object} is a character string ending in ".Rd" and containing a forward slash (i.e. it looks like Rd file in a directory), then it is taken to be \code{infile}. \code{Rdtext} is similar to \code{infile} but the Rd content is taken from a character vector. If Rd content is supplied by \code{infile} or \code{Rdtext}, \code{reprompt} uses it as a basis for comparison. Otherwise it tries to find installed documentation for the object or topic requested. If that fails, it resorts to one of the \code{promptXXX} functions to generate a documentation shell. If that also fails, the requested object or topic does not exist. If the above succeeds, the function examines the current definition of the requested object(s), methods, or class and amends the documentation with any additional items it finds. For Rd objects describing one or more functions, the usage expressions are checked and replaced, if they have changed. Arguments appearing in one or more usage expressions and missing from section "Arguments" are amended to it with content "Describe ..." and a message is printed. Arguments no longer in the usage statements are NOT removed but a message is issued to alert the user. Alias sections are inserted for any functions with "usage" but without "alias" section. If \code{filename} is a character string, it is used as is, so any path should be included in the string. Argument \code{filename} usuallly is omitted since the automatically generated file name is suitable in most cases. Exceptions are functions with non-standard names (such as replacement functions whose names end in \code{"<-"}) for which the generated file names may not be acceptable on some operating systems. If \code{filename} is missing or \code{NULL}, a suitable name is generated as follows. If \code{infile} is supplied, \code{filename} is set to a file with the same name in the current working directory (i.e. any path information in \code{infile} is dropped). Otherwise, \code{filename} is obtained by appending the name tag of the Rd object with \code{".Rd"}. If \code{filename} is \code{TRUE}, it is set to \code{infile} or, if \code{infile} is missing or \code{NULL}, a suitable name is generated as above. This can be used to change \code{infile} in place. If \code{filename} is \code{FALSE}, the Rd text is returned as a character vector and not written to a file. If \code{edit} is \code{TRUE}, the reprompted file is opened in an editor, see also \code{\link{ereprompt}} (`e' for `edit') which is like \code{reprompt} but has as default \code{edit = TRUE} and some other related settings. \code{file.edit()} is used to call the editor. Which editor is opened depends on the OS and on the user configuration. RStudio users will probably prefer the 'Reprompt' add-in or the underlying function \code{\link{RStudio_reprompt}}. Emacs users would normally have set up \code{emacsclient} as their editor and this is automatically done by EMACS/ESS (even on Windows). If argument \code{sec_copy} is \code{TRUE} (the default), \code{reprompt} will, effectively, copy the contents of (some) unchanged sections, thus ensuring that they are exactly the same as in the original. This needs additional work, since parsing an Rd file and then exporting the created Rd object to an Rd file does not necessarilly produce an identical Rd file (some escape sequences may be changed in the process, for example). Even though the new version should be functionally equivalent to the original, such changes are usually not desirable. For example, if such changes creep into the Details section (which \code{reprompt} never changes) the user may be annoyed or worried. } \value{ if \code{filename} is a character string or \code{NULL}, the name of the file to which the updated shell was written. Otherwise, the Rd text is returned as a character vector. } \author{Georgi N. Boshnakov} \note{ The arguments of \code{reprompt} are similar to prompt, with some additions. As in \code{prompt}, \code{filename} specifies the output file. In \code{reprompt} a new argument, \code{infile}, specifies the input file containing the Rd source. When \code{reprompt} is used to update sources of Rd documentation for a package, it is best to supply the original Rd file in argument \code{infile}. Otherwise, if the original Rd file contains \verb{\Sexpr} commands, \code{reprompt} may not be able to recover the original Rd content from the installed documentation. Also, the fields (e.g. the keywords) in the installed documentation may not be were you expect them to be. (This may be addressed in a future revision.) While \code{reprompt} adds new items to the documentation, it never removes existing content. It only issues a suggestion to remove an item, if it does not seem necessary any more (e.g. a removed argument from a function definition). \code{reprompt} handles usage statements for S3 and S4 methods introduced with any of the macros \verb{\method}, \verb{\S3method} and \verb{\S4method}, as in \verb{\method{fun}{class}(args...)}. \code{reprompt} understands also subsetting ans subassignment operators. For example, suppose that the \code{\\arguments} section of file "bracket.Rd" contains these directives (or any other wrong signatures): \preformatted{ \method{[}{ts}() \method{[[}{Date}() } Then \code{reprompt("./bracket.Rd")} will change them to \preformatted{ \method{[}{ts}(x, i, j, drop = TRUE) \method{[[}{Date}(x, \dots, drop = TRUE) } This works for the assignment operators and functions, as well. For example, any of these \preformatted{ \method{`[<-`}{POSIXlt}() \method{[}{POSIXlt}(x, j) <- value } will be converted by \code{reprompt} to the standard form \preformatted{ \method{[}{POSIXlt}(x, i, j) <- value } Note that the quotes in \code{`[<-`} above. Usage statements for functions are split over two or more lines if necessary. The user may edit them afterwards if the automatic splitting is not appropriate, see below. The usage section of Rd objects describing functions is left intact if the usage has not changed. To force \code{reprompt} to recreate the usage section (e.g. to reformat long lines), invalidate the usage of one of the described functions by removing an argument from its usage expression. Currently the usage section is recreated completely if the usage of any of the described functions has changed. Manual formatting may be lost in such cases. } %% ~Make other sections like Warning with \section{Warning }{....} ~ \seealso{ \code{\link{ereprompt}} which by default calls the editor on the original file } \examples{ ## note: usage of reprompt() is simple. the examples below are bulky ## because they simulate various usage scenarios with commands, ## while in normal usage they would be due to editing. ## change to a temporary directory to avoid clogging up user's cur_wd <- getwd() tmpdir <- tempdir() setwd(tmpdir) ## as for prompt() the default is to save in current dir as "seq.Rd". ## the argument here is a function, reprompt finds its doc and ## updates all objects described along with `seq'. ## (In this case there is nothing to update, we have not changed `seq'.) fnseq <- reprompt(seq) ## let's parse the saved Rd file (the filename is returned by reprompt) rdoseq <- tools::parse_Rd(fnseq) # parse fnseq to see the result. Rdo_show(rdoseq) ## we replace usage statements with wrong ones for illustration. ## (note there is an S3 method along with the functions) dummy_usage <- char2Rdpiece(paste("seq()", "\\\\method{seq}{default}()", "seq.int()", "seq_along()", "seq_len()", sep="\n"), "usage") rdoseq_dummy <- Rdo_replace_section(rdoseq, dummy_usage) Rdo_show(rdoseq_dummy) # usage statements are wrong reprompt(rdoseq_dummy, file = "seqA.Rd") Rdo_show(tools::parse_Rd("seqA.Rd")) # usage ok after reprompt ## define function myseq() myseq <- function(from, to, x){ if(to < 0) { seq(from = from, to = length(x) + to) } else seq(from, to) } ## we wish to describe myseq() along with seq(); ## it is sufficient to put myseq() in the usage section ## and let reprompt() do the rest rdo2 <- Rdo_modify_simple(rdoseq, "myseq()", "usage") reprompt(rdo2, file = "seqB.Rd") # updates usage of myseq ## show the rendered result: Rdo_show(tools::parse_Rd("seqB.Rd")) ## Run this if you wish to see the Rd file: ## file.show("seqB.Rd") reprompt(infile = "seq.Rd", filename = "seq2.Rd") reprompt(infile = "seq2.Rd", filename = "seq3.Rd") ## Rd objects for installed help may need some tidying for human editing. #hseq_inst <- help("seq") #rdo <- utils:::.getHelpFile(hseq_inst) rdo <- Rdo_fetch("seq", "base") rdo rdo <- Rdpack:::.Rd_tidy(rdo) # tidy up (e.g. insert new lines # for human readers) reprompt(rdo) # rdo and rdoseq are equivalent all.equal(reprompt(rdo), reprompt(rdoseq)) # TRUE ## clean up unlink("seq.Rd") # remove temporary files unlink("seq2.Rd") unlink("seq3.Rd") unlink("seqA.Rd") unlink("seqB.Rd") setwd(cur_wd) # restore user's working directory unlink(tmpdir) } % Add one or more standard keywords, see file 'KEYWORDS' in the % R documentation directory. \keyword{Rd} Rdpack/inst/examples/Rdpack-package.Rd0000644000175000017500000004207113756515650017510 0ustar nileshnilesh\name{Rdpack-package} \alias{Rdpack-package} \alias{Rdpack} \docType{package} \title{ \Sexpr[stage=build,results=hide]{require(Rdpack)} \Sexpr[stage=build,results=hide]{pd <- utils::packageDescription("Rdpack")} \Sexpr[stage=build,results=hide]{lb <- library(help="Rdpack", character.only=TRUE)} \Sexpr[stage=build]{pd$Title} } \description{ \Sexpr[stage=build]{pd$Description} } \details{ \tabular{ll}{ Package: \tab \Sexpr[stage=build]{pd$Package}\cr Type: \tab \Sexpr[stage=build]{pd$Type}\cr Version: \tab \Sexpr[stage=build]{pd$Version} \cr Date: \tab \Sexpr[stage=build]{pd$Date}\cr License: \tab \Sexpr[stage=build]{pd$License}\cr LazyLoad: \tab \Sexpr[stage=build]{pd$LazyLoad}\cr Built: \tab \Sexpr[stage=build]{pd$Built} } % % 2018-05-24 commenting out % Index: % % \Sexpr[stage=build,results=rd]{paste("\\\\preformatted{", paste(if(!is.null(lb$info[[2]])) lb$info[[2]] else "No entries",collapse="\\n"), "}", sep="")} % % Package \code{Rdpack} provides a number of functions for maintenance of documentation in \R packages. Although base \R and package \code{methods} have functions for creation of skeleton documentation, if a function gets a new argument or a generic gets a new method, then updating existing documentation is somewhat inconvenient. This package provides functions that update parts of the Rd documentation that can be dealt with automatically and leave manual changes untouched. For example, usage sections for functions are updated and if there are undescribed arguments, additional items are put in the `arguments' section. A set of functions and macros support inclusion of references and citations from BibTeX files in \R documentation (Rd and roxygen2). These tools use only facilities provided by base \R and package \pkg{rbibutils} \insertCite{Rpackage:rbibutils}{Rdpack}. There are also convenience macros for inclusion of evaluated examples and graphs, which hide some of the hassle of doing this directly with the underlying \verb{\Sexpr}'s. The subsections below give additional details, see also the vignettes. \subsection{Creating and updating Rd files}{ The main function provided by this package is \code{\link{reprompt}}. There is also a function \code{\link{promptPackageSexpr}} for creating initial skeleton for overall package description such as this help page. \code{\link{reprompt}} produces a skeleton documentation for the requested object, similarly to functions like \code{prompt}, \code{promptMethods}, and \code{promptClass}. Unlike those functions, \code{\link{reprompt}} updates existing documentation (installed or in an Rd object or file) and produces a skeleton from scratch as a last resort only. If the documentation object describes more than one function, all descriptions are updated. Basically, \code{\link{reprompt}} updates things that are generated automatically, leaving manual editing untouched. The typical use of \code{reprompt} is with one argument, as in \preformatted{ reprompt(infile = "./Rdpack/man/reprompt.Rd") reprompt(reprompt) reprompt("reprompt") } \code{reprompt} updates the documentation of all objects described in the Rd object or file, and writes the updated Rd file in the current working directory, see \code{\link{reprompt}} for details. To describe a new function in an existing Rd file, just add something like \code{myfun()} and run reprompt to insert the correct signature, alias, etc. This works also for replacement functions, see \code{\link{reprompt}} for details. \code{\link{ereprompt}} updates the Rd documentation in a file, overwrites it and opens it in an editor. It calls \code{reprompt} to do the actual job but has different defaults. Which editor is opened, is system dependent, see the \code{\link[utils]{edit}} and \code{\link{ereprompt}} for futher details. Users who work on Rd files in RStudio can use add-in \dQuote{Reprompt} to invoke \code{reprompt} conveniently on an Rd file or on a selected object in an \R source code file, see \code{\link{RStudio_reprompt}}. This add-in was contributed by Duncan Murdoch. Users of Emacs/ESS have various options, depending on their workflow. One approach is to define a key to call \code{\link{ereprompt}} on the file being edited, see \href{https://github.com/GeoBosh/georgisemacs}{georgisemacs} for an example setup. \code{\link{promptPackageSexpr}} creates a skeleton for a package overview in file \verb{name-package.Rd}. Then the file can be edited as needed. This function needs to be called only once for a package since automatic generation of information in \verb{name-package.Rd} is achieved with Sexpr's at build time, not with verbatim strings (\code{promptPackage} used to insert verbatim strings but in recent versions of \R it also uses macros.). For example, the source of this help page is file `Rdpack-package.Rd'. It was initially produced using \preformatted{ promptPackageSexpr("Rdpack") } The factual information at the beginning of this help topic (the index above, the version and other stuff that can be determined automatically) is kept automatically up to date. } \subsection{References and Citations}{ Another set of functions is for management of bibliographic references in Rd files. The old approach based on function \code{\link{rebib}} is fully functional, see below, but the recommended way to insert references and citations is based on Rd macros. The provided Rd macros are fully portable and, in particular, work in Rd files and roxygen2 comments, see \code{\link{insertRef}} and vignette \code{vignette("Inserting_bibtex_references", "Rdpack")} for details and examples. The Bibtex source for the references and citations produced by the Rd macros is file "REFERENCES.bib", which should be located in the root of the package installation directory. \pkg{Rdpack} needs also to be mentioned in two places in file `DESCRIPTION'. These one-off preparation steps are enumerated below: \enumerate{ \item{ Put the following line in file `DESCRIPTION': \cr \verb{RdMacros: Rdpack} \cr (If there is already a line starting with 'RdMacros:', add \pkg{Rdpack} to the list on that line.) } \item{ Add \pkg{Rdpack} to the list of imports (\verb{Imports:} field) in file `DESCRIPTION'. } \item{ Add the following line to file `NAMESPACE': \preformatted{ importFrom(Rdpack,reprompt) } Alternatively, if \pkg{devtools} is managing your NAMESPACE file, the equivalent \pkg{roxygen2} line is: \preformatted{ #' @importFrom Rdpack reprompt} } \item{ Create file \code{"REFERENCES.bib"} in subdirectory \code{"inst/"} of the package and put the BibTeX references in that file. } } The Rd macro \code{\\insertRef} takes two arguments: a BibTeX key and the name of a package. Thus, \code{\\insertRef{key}{package}} inserts the reference whose key is \code{key} from "REFERENCES.bib" of the specified package (almost always the one being documented). % With \pkg{Rdpack (>= 0.6-1)}, Citations can be done with Rd macro \code{\\insertCite}, which inserts citation(s) for one or more BibTeX keys and records the keys. \code{\\insertCiteOnly} is similar to \code{\\insertCite} but does not record the keys. \code{\\insertNoCite} records the keys but does not produce citations. \code{\\insertAllCited} creates a bibliography including all references recorded by \code{\\insertCite} and \code{\\insertNoCite}. It is usually put in section \dQuote{References}, something like: \preformatted{ \references{ \insertAllCited{} } } in an Rd file. Don't align the backslash with the second 'e' of \code{@references}, since roxygen2 may interpret it as verbatim text, not macro. The analogous documentation chunk in roxygen2 might look like this: \preformatted{ #' @references #' \insertAllCited{} } Bibliography styles for lists of references are supported as well. Currently the only alternative offered is to use long names (Georgi N. Boshnakov) in place of the default style (Boshnakov GN). More comprehensive alternatives can be included if needed or requested. Convenience functions \code{\link{makeVignetteReference}} and \code{\link{vigbib}} generate Bibtex entries for vignettes. } \subsection{Previewing documentation pages}{ It is convenient during development to be able to view the rendered version of the document page being edited. The function \code{\link{viewRd}} renders a documentation file in a source package and displays it as text or in a browser. It renders references properly in any workflow, including \pkg{devtools} development mode \insertCite{Rdevtools}{Rdpack} in Emacs/ESS, Rstudio, Rgui. This function is a good candidate to be assigned to a key in editors which support this. I created this function (in 2017) since the functions provided by \pkg{devtools} and Emacs/ESS are giving errors when processing pages containing Rd macros. } \subsection{Static Management of References}{ In the alternative approach, the function \code{\link{rebib}} updates the bibliographic references in an Rd file. Rdpack uses a simple scheme for inclusion of bibliographic references. The key for each reference is in a TeX comment line, as in: \preformatted{ \references{ ... \% bibentry: key1 \% bibentry: key2 ... } } \code{rebib} puts each reference after the line containing its key. It does nothing if the reference has been put by a previous call of \code{rebib}. If the Bibtex entry for some references changes, it may be necessary to update them in the Rd file, as well. Call \code{rebib} with \code{force = TRUE} to get this effect. There is also a facility to include all references from the Bibtex file, see the documentation of \code{\link{rebib}} for details. } \subsection{Inserting evaluated examples}{ Sometimes the documentation of an object becomes more clear if accompanied by snippets of R code and their results. The standard Rd macro \verb{\Sexpr} caters for a number of possibilities to evaluate \R code and insert the results and the code in the documentation. The Rd macro \verb{\printExample} provided by package \pkg{Rdpack} builds on it to print a snippet of \R code and the results of its evaluation, similarly to console output but the code is not prefixed and the results are prefixed with comment symbols. For example, \verb{\printExample{2+2; a <- 2*3; a}} produces the following in the rendered documentation: \printExample{2+2; a <- 2*3; a} The help page of \code{\link{promptUsage}} contains a number of examples created with \code{\\printExample}. The corresponding Rd file can be obtained from the package tarball or from \url{https://github.com/GeoBosh/Rdpack/blob/master/man/promptUsage.Rd}. The argument of \verb{\printExample} must be on a single line with versions of R before R 3.6.0. \verb{\printExample} is typically placed in section Details of an object's documentation, see section Details of \code{\link{get_usage}} for anumber of examples produced mostly with \verb{\printExample}. The macro \verb{\runExamples} can be used as a replacement of section \verb{Examples}. For example, if the following code is put at the top level in an Rd file (i.e. not in a section): \preformatted{ \runExamples{2+2; a <- 2*3; a} } then it will be evaluated and replaced by a normal section examples: \preformatted{ \examples{ 2 + 2 ##: 4 a <- 2 * 3 a ##: 6 } } This generated examples section is processed by the standard \R tools (almost) as if it was there from the outset. In particular, the examples are run by the R's quality control tools and tangled along with examples in other documentation files. In \R versions before 3.6.0 \verb{R CMD check} used to give a warning about unknown \verb{\Sexpr} section at top level. % According to the specification of the Rd format, \insertCite{@see @parseRd, % p. 4;textual}{Rdpack} \verb{\Sexpr} at top level is legal but I need to check with the CRAN % team or R devel if such expressions produced by user macros are excluded on purpose. } \subsection{Creating and including graphs}{ Figures can be inserted with the help of the standard Rd markup command \verb{\figure}. The Rd macro \verb{\insertFig} provided by package \pkg{Rdpack} takes a snipped of \R code, evaluates it and inserts the plot produced by it (using \verb{\figure}). \verb{\insertFig} takes three arguments: a filename, the package name and the code to evaluate to produce the figure. For example, \preformatted{ \insertFig{cars.png}{mypackage}{x <- cars$speed; y <- cars$dist; plot(x,y)} } will evaluate the code, save the graph in file \code{"man/figures/cars.png"} subdirectory of package \code{"mypackage"}, and include the figure using \verb{\figure}. Subdirectory \code{"figures"} is created if it doesn't exist. Currently the graphs are saved in \code{"png"} format only. In older versions of \R the code should be on a single line for the reasons explained in the discussion of \verb{\printExample}. The sister macro \verb{\makeFig} creates the graph in exactly the same way as \verb{\insertFig} but does not insert it. This can be done with a separate \verb{\figure} command. This can be used if additional options are desired for different output formats, see the description of \verb{\figure} in "Writing R extensions". } Other functions that may be useful are \code{Rdo2Rdf}, \code{Rdapply} and \code{Rd_combo}. Here is also brief information about some more technical functions that may be helpful in certain circumstances. \code{\link{get_usage}} generates usage text for functions and methods. The functions can be located in environments or other objects. This may be useful for description of function elements of compound objects. \code{\link{c_Rd}} concatenates Rd pieces, character strings and lists to create a larger Rd piece or a complete Rd object. \code{\link{list_Rd}} is similar to \code{\link{c_Rd}} but provides additional features for convenient assembling of Rd objects. \code{\link{parse_Rdpiece}} is a technical function for parsing pieces of Rd source text but it has an argument to return formatted help text which may be useful when one wishes to show it to the user. \code{Rdo_set_section} can be used to set a section, such as "\verb{\author}". The remaining functions in the package are for programming with Rd objects. } \author{ \Sexpr[stage=build]{pd$Author} Maintainer: \Sexpr[stage=build]{pd$Maintainer} } \note{ All processing is done on the parsed Rd objects, i.e. objects of class "Rd" or pieces of such objects \insertCite{parseRd}{Rdpack}. The following terminology is used (todo: probably not yet consistently) throughout the documentation. "Rd object" - an object of class Rd, or part of such object. "Rd piece" - part of an object of class Rd. Fragment is also used but note that \code{parse_Rd} defines fragment more restrictively. "Rd text", "Rd source text", "Rd format" - these refer to the text of the Rd files. } \seealso{ % \code{\link[:-package]{}} ~~ \code{\link{ereprompt}}, \code{\link{reprompt}}, \code{\link{promptPackageSexpr}}, \code{\link{rebib}}, \code{\link{get_usage}}, \code{\link{viewRd}}, \code{\link{vigbib}}, \code{\link{makeVignetteReference}}, \code{vignette("Inserting_bibtex_references", package = "Rdpack")}, \code{vignette("Inserting_figures_and_evaluated_examples", package = "Rdpack")} } \references{ \strong{Note:} Reference \insertCite{dummyArticle;textual}{Rdpack} does not exist. It is a test that simple math in BibTeX entries works. --- \insertAllCited{} } \examples{ ## The examples below show typical use but are not executable. ## For executable examples see the help pages of ## reprompt, promptPackageSexpr, and rebib. ## To make the examples executable, replace "myfun" with a real ## function, and similarly for classes and paths to files. \dontrun{ ## update the doc. from the Rd source and save myfun.Rd ## in the current directory (like prompt) reprompt(infile="path/to/mypackage/man/myfun.Rd") ## update doc of myfun() from the installed doc (if any); ## if none is found, create it like prompt reprompt("myfun") reprompt(myfun) # same ## update doc. for S4 methods from Rd source reprompt(infile="path/to/mypackage/man/myfun-methods.Rd") ## update doc. for S4 methods from installed doc (if any); ## if none is found, create it like promptMethods reprompt("myfun", type = "methods") reprompt("myfun-methods") # same ## update doc. for S4 class from Rd source reprompt(infile="path/to/mypackage/man/myclass-class.Rd") ## update doc. of S4 class from installed doc. ## if none is found, create it like promptClass reprompt("myclass-class") reprompt("myclass", type = "class") # same ## create a skeleton "mypackage-package.Rd" promptPackageSexpr("mypackage") ## update the references in "mypackage-package.Rd" rebib(infile="path/to/mypackage/man/mypackage-package.Rd", force=TRUE) } } \keyword{ package } Rdpack/inst/examples/url_with_percents.bib0000644000175000017500000000043413501141722020616 0ustar nileshnilesh@article{urlWithPercents, title = {Dummy example of {URL} with percents}, volume = {51}, url = {https://github.com/GeoBosh/zzfiles/blob/master/url%20with%20percents.bib}, journal = {Example bibtex file}, author = {Boshnakov, Georgi N.}, year = {2018}, pages = {1--1} } Rdpack/inst/examples/RdpackTester/0000755000175000017500000000000014204025772017001 5ustar nileshnileshRdpack/inst/examples/RdpackTester/DESCRIPTION0000644000175000017500000000065113501141722020502 0ustar nileshnileshPackage: RdpackTester Type: Package Title: Testbed for Rdpack Version: 1.0 Date: 2018-09-22 Author: Georgi N. Boshnakov Maintainer: Description: A lot of the functionality of package 'Rdpack' is best tested on a package. This package is part of 'Rdpack' and is used for that purpose. License: GPL (>=2) RdMacros: Rdpack NeedsCompilation: no Packaged: 2018-09-22 13:55:28 UTC; mcbssgb2 Rdpack/inst/examples/RdpackTester/man/0000755000175000017500000000000013501141722017545 5ustar nileshnileshRdpack/inst/examples/RdpackTester/man/RdpackTester-package.Rd0000644000175000017500000000230513501141722024020 0ustar nileshnilesh\name{RdpackTester-package} \alias{RdpackTester-package} \alias{RdpackTester} \docType{package} \title{ \packageTitle{RdpackTester} } \description{ \packageDescription{RdpackTester} } \details{ The DESCRIPTION file: \packageDESCRIPTION{RdpackTester} %\packageIndices{RdpackTester} Some of the references here are non-existent or a modified to test/demonstrate features of the citation macros. \strong{Note:} Reference \insertCite{dummyArticle;textual}{Rdpack} does not exist. It is a test that simple math in BibTeX entries works. \insertCite{nadler_diffusion_2005}{Rdpack} \insertCite{cayton_robust_2006}{Rdpack} \insertCite{fukunaga_introduction_1990}{Rdpack} \insertCite{fukunaga_introduction_1990_fake_vol}{Rdpack} \insertCite{fukunaga_introduction_1990_fake_number}{Rdpack} \insertCite{fukunaga_introduction_1990_fake_vol_number}{Rdpack} } \author{ \packageAuthor{RdpackTester} Maintainer: \packageMaintainer{RdpackTester} } \references{ \insertAllCited{} --- Formulas are handled in fields were they make sense, here title, journal, note: \insertRef{dummyArticle}{Rdpack} } \keyword{ package } %\seealso{ %~~ \code{\link[:-package]{}} ~~ %} \examples{ test_1() } Rdpack/inst/examples/RdpackTester/R/0000755000175000017500000000000013501141722017173 5ustar nileshnileshRdpack/inst/examples/RdpackTester/R/RdpackTester-internal.R0000644000175000017500000000007513501141722023525 0ustar nileshnileshtest_1 <- function(x,y){ "This function does nothing." } Rdpack/inst/examples/RdpackTester/inst/0000755000175000017500000000000013501141722017747 5ustar nileshnileshRdpack/inst/examples/RdpackTester/inst/auto/0000755000175000017500000000000013501141722020717 5ustar nileshnileshRdpack/inst/examples/RdpackTester/inst/auto/REFERENCES.el0000644000175000017500000000056413501141722022667 0ustar nileshnilesh(TeX-add-style-hook "REFERENCES" (lambda () (LaTeX-add-bibitems "Rpack:bibtex" "parseRd" "Rdevtools" "dummyArticle" "nadler_diffusion_2005" "cayton_robust_2006" "fukunaga_introduction_1990" "fukunaga_introduction_1990_fake_vol" "fukunaga_introduction_1990_fake_number" "fukunaga_introduction_1990_fake_vol_number")) :bibtex) Rdpack/inst/examples/RdpackTester/inst/REFERENCES.bib0000644000175000017500000001032513501141722022047 0ustar nileshnilesh@Manual{Rpack:bibtex, title = {bibtex: bibtex parser}, author = {Romain Francois}, year = {2014}, note = {R package version 0.4.0}, url = {https://CRAN.R-project.org/package=bibtex}, } @misc{parseRd, title = {Parsing Rd files}, author = {Duncan Murdoch}, year = {2010}, url = {https://developer.r-project.org/parseRd.pdf}, } @Manual{Rdevtools, title = {devtools: Tools to Make Developing R Packages Easier}, author = {Hadley Wickham and Jim Hester and Winston Chang}, year = {2018}, note = {R package version 1.13.5}, url = {https://CRAN.R-project.org/package=devtools}, } @Article{dummyArticle, title = {A relation between several fundamental constants: $e^{i\pi}=-1$}, journal = {A non-existent journal with the formula $L_2$ in its name.}, author = {A. ZZZ}, year = {2018}, note = {This reference does not exist. It is a test/demo that simple formulas in BibTeX files are OK. A formula in field 'note': $c^2 = a^2 + b^2$.}, } @inproceedings{nadler_diffusion_2005, address = {Cambridge, MA, USA}, series = {{NIPS}'05}, title = {Diffusion {Maps}, {Spectral} {Clustering} and {Eigenfunctions} of {Fokker}-{Planck} {Operators}}, url = {http://dl.acm.org/citation.cfm?id=2976248.2976368}, booktitle = {Proceedings of the 18th {International} {Conference} on {Neural} {Information} {Processing} {Systems}}, publisher = {MIT Press}, author = {Nadler, Boaz and Lafon, Stphane and Coifman, Ronald R. and Kevrekidis, Ioannis G.}, year = {2005}, keywords = {algorithms and architectures, learning theory}, pages = {955--962}, file = {[Nadler.2005] Diffusion Maps, Spectral Clustering and Eigenfunctions of Fokker-Planck.pdf:/home/kisung/Dropbox/V3. Statistics/P3. Dimension Reduction/S2. Nonlinear/01. DM/[Nadler.2005] Diffusion Maps, Spectral Clustering and Eigenfunctions of Fokker-Planck.pdf:application/pdf} } @inproceedings{cayton_robust_2006, address = {New York, NY, USA}, series = {{ICML} '06}, title = {Robust {Euclidean} {Embedding}}, isbn = {1-59593-383-2}, url = {http://doi.acm.org/10.1145/1143844.1143866}, doi = {10.1145/1143844.1143866}, booktitle = {Proceedings of the 23rd {International} {Conference} on {Machine} {Learning}}, publisher = {ACM}, author = {Cayton, Lawrence and Dasgupta, Sanjoy}, year = {2006}, pages = {169--176}, file = {[Cayton_Dasgupta.2006] Robust Euclidean Embedding.pdf:/home/kisung/Dropbox/V3. Statistics/P3. Dimension Reduction/S2. Nonlinear/27. REE/[Cayton_Dasgupta.2006] Robust Euclidean Embedding.pdf:application/pdf} } @book{fukunaga_introduction_1990, address = {Boston}, edition = {Second}, series = {Computer science and scientific computing}, title = {Introduction to statistical pattern recognition}, isbn = {978-0-12-269851-4}, publisher = {Academic Press}, author = {Fukunaga, Keinosuke}, year = {1990}, keywords = {Mathematical models, Mathematical statistics, Pattern perception, Decision making, Statistical methods}, file = {[Fukunaga.1990] Introduction to statistical pattern recognition.pdf:/home/kisung/Dropbox/V3. Statistics/P3. Dimension Reduction/S1. Linear/06. LDA_RDA/[Fukunaga.1990] Introduction to statistical pattern recognition.pdf:application/pdf} } @book{fukunaga_introduction_1990_fake_vol, address = {Boston}, edition = {Second}, series = {Computer science and scientific computing}, volume = {82}, title = {Introduction to statistical pattern recognition}, isbn = {978-0-12-269851-4}, publisher = {Academic Press}, author = {Fukunaga, Keinosuke}, year = {1990}, } @book{fukunaga_introduction_1990_fake_number, address = {Boston}, edition = {Second}, series = {Computer science and scientific computing}, number = {2}, title = {Introduction to statistical pattern recognition}, isbn = {978-0-12-269851-4}, publisher = {Academic Press}, author = {Fukunaga, Keinosuke}, year = {1990}, } @book{fukunaga_introduction_1990_fake_vol_number, address = {Boston}, edition = {Second}, series = {Computer science and scientific computing}, volume = {82}, number = {2}, title = {Introduction to statistical pattern recognition}, isbn = {978-0-12-269851-4}, publisher = {Academic Press}, author = {Fukunaga, Keinosuke}, year = {1990}, } Rdpack/inst/examples/RdpackTester/NAMESPACE0000644000175000017500000000003713501141722020211 0ustar nileshnileshexportPattern("^[[:alpha:]]+") Rdpack/inst/RStudio/0000755000175000017500000000000013501141722014152 5ustar nileshnileshRdpack/inst/RStudio/addins.dcf0000644000175000017500000000016213501141722016071 0ustar nileshnileshName: Reprompt Description: Updates Rd file based on editor contents Binding: RStudio_reprompt Interactive: false Rdpack/NAMESPACE0000644000175000017500000000470614041050464013034 0ustar nileshnileshimport(methods) importFrom(utils, bibentry, browseURL, capture.output, cite, file.edit, getAnywhere, getS3method, head, help, packageDescription, packageVersion, person, prompt, vignette) importFrom(tools, parse_Rd, toRd, checkRd, Rd2txt, bibstyle, latexToUtf8, parseLatex, deparseLatex) #importFrom(grDevices, dev.off, png) #importFrom(gbRd, Rd_help2txt) # commented out 2020-11-25 #importFrom(bibtex, read.bib) importFrom(rbibutils, readBib) S3method(as.character, f_usage) S3method(print, f_usage) S3method(print, bibentryRd) export( append_to_Rd_list , as.character.f_usage # , bibentry_key , c_Rd , char2Rdpiece , compare_usage1 , deparse_usage , deparse_usage1 , format_funusage , get_bibentries , get_sig_text , get_usage , get_usage_text , insert_ref , inspect_args , inspect_clmethods , inspect_Rd , inspect_Rdbib , inspect_Rdclass , inspect_Rdfun , inspect_Rdmethods , inspect_signatures , inspect_slots , inspect_usage , is_Rdsecname , list_Rd , pairlist2f_usage1 , parse_1usage_text , parse_pairlist , parse_Rdname , parse_Rdpiece , parse_Rdtext # , parse_text , parse_usage_text , promptPackageSexpr , promptUsage , rattr , Rd_combo , Rdapply , Rdo_append_argument , Rdo_collect_aliases , Rdo_comment , Rdo_drop_empty , Rdo_empty_sections , Rdo_flatinsert , Rdo_flatremove , Rdo_get_argument_names , Rdo_get_insert_pos , Rdo_get_item_labels , Rdo_insert , Rdo_insert_element , Rdo_is_newline , Rdo_item , Rdo_locate , Rdo_locate_core_section , Rdo_locate_leaves # , Rdo_locate_leaves2 # , Rdo_locate_predefined_section , Rdo_macro , Rdo_macro1 , Rdo_macro2 , Rdo_modify , Rdo_modify_simple , Rdo_newline , Rdo_piece_types , Rdo_piecetag , Rdo_predefined_sections , Rdo_Rcode , Rdo_remove_srcref , Rdo_reparse , Rdo_replace_section , Rdo_sections , Rdo_sectype , Rdo_set_section , Rdo_show , Rdo_sigitem , Rdo_tag , Rdo_tags , Rdo_text , rdo_text_restore , rdo_top_tags , Rdo_verb , Rdo_which , Rdo_which_tag_eq , Rdo_which_tag_in , Rdo2Rdf , Rdreplace_section , Rdtagapply , rebib , reprompt , RStudio_reprompt , S4formals # , toolsdotdotdot.Rd_drop_nodes_with_tags # , toolsdotdotdot.Rd_get_metadata # , toolsdotdotdotfetchRdDB # , toolsdotdotdotRdTags , update_aliases_tmp # , utilsdotdotdot.getHelpFile , viewRd , makeVignetteReference , vigbib , ereprompt , insert_citeOnly , insert_all_ref , Rdpack_bibstyles , set_Rdpack_bibstyle # , run_examples - commenting out until completed # , insert_fig - commenting out until completed , Rdo_fetch )