LEFT TEXT
config/_library-config/index-include.md.cms
config/_library-config/sitemap-include.md.cms
(continued)
#WORK
<!-- composer >> metainfo -->
| site-config | defaults | values |
|---|---|---|
| brand null | null | |
| homepage null | null | |
| search :: name null | null | |
| search :: site null | null | |
| search :: call null | null | |
| search :: form null | null | |
| copyright null | null | |
composer 1 |
1 |
|
header null |
`../../con | fig/_header.md.cms` |
footer null |
`../../con | fig/_footer.md.cms` |
css_overlay dark |
null |
|
copy_protect null |
1 |
|
cols_break lg |
md |
|
cols_scroll 1 |
null |
|
| cols_order `[ 1, 2, 3 | ] |
]` |
| cols_reorder `[ 1, 3, 2 | ] |
]` |
| cols_size `[ 3, 7, 2 | ] |
3 ]` |
| cols_resize `[ 6, 12, | 6 ] |
0 ]` |
| metainfo ` |
bsp; ( – <author| – > . <tags| . >` |
|
metainfo_null *(none)* |
null |
|
| metalist :: author title: ` | Author{=html} *display:*Authors: <|>, <|>title:Cr |
eator{=html} display: |
| metalist :: tags title: ` | Tag{=html} *display:*Tags: <|>, <|>title:Ma |
rk{=html} display: |
| readtime `*Reading | time: |
word> / Minutes: |
readtime_wpm 220 |
200 |
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)
The ideal workflow is to put Composer in a top-level .Composer for each directory tree you want to manage, creating a structure similar to this:
.../.Composer
.../
.../tld/
.../tld/sub/To save on disk space, using a central Composer install for multiple directory trees, the init target can be used to create a linked .Composer directory:
make -f .../Makefile initThe directory tree can then be converted to a Composer documentation archive (Quick Start example):
make -f .Composer/Makefile install-all
make all-allIf specific settings need to be used, either globally or per-directory, .composer.mk and .composer.yml files can be created (see Configuration Settings, Quick Start example):
make template >.composer.mk && $EDITOR .composer.mk
make template.yml >.composer.yml && $EDITOR .composer.ymlCustom targets can also be defined, using standard GNU Make syntax (see Custom Targets).
GNU Make does not support file and directory names with spaces in them, and neither does Composer. Documentation archives which have such files or directories will produce unexpected results.
It is fully supported for input files to be symbolic links to files that reside outside the documentation archive:
cd .../tld
ln -rs .../README.md ./
make README.htmlSimilarly to source code, GNU Make is meant to only run one instance within the directory at a time, and Composer shares this requirement. It should be run as a single user, to avoid duplication and conflicts. Concurrent runs will produce unexpected results. It is highly recommended to set MAKEJOBS to a value greater than the default, to speed up processing.
(continued)