; example manifest file for application bundler.

[toc]
set_target=t
set_bogus=t
set_nechung_dir=t
using_target=t
using_vars=t
absolute_path=t
wildcard_congelio=t
wildcard_specific=t
recursing_doodle=t
execute_source_side=t
execute_target_side=t
target_exec_sans_source=t
error_check=t
no_replacement=t

[set_target]
variable=TARGET=$TMP/bundle_example_yo
; this is an example of setting a variable.  the variables found in a section
; should be the only content provided (no source or target is needed).  in
; this example, the variable is "TARGET" and it's being set to a folder under
; the TMP directory.
; "TARGET" is actually a special variable; it is the main installation root
; for all bundled products.  if it is going to be overridden, it should be the
; first item in the table of contents; this ensures all other targets see
; the chosen default target location.

[set_bogus]
variable=BOGUS=petunias
; this is a simple variable that can be used to test overriding variables by
; passing them on the command line to the unpacker exe.

[set_nechung_dir]
variable=NECHUNG=$REPOSITORY_DIR/source/app_src/nechung/example.txt
; provides the nechung oracle (used later) with a datafile.

[using_target]
source=$REPOSITORY_DIR/exe/bytedump$EXE_END
target=$TARGET/bytedunker$EXE_END
; a special variable called TARGET is the default location where files will
; be stored.  this is basically the main installation folder.  the TARGET
; folder can be specified on the command line when a bundle is installed.
; note the automatic variable called EXE_END; this is set to ".exe" for win32
; operating systems and is blank for others (so far).

[using_vars]
source=$REPOSITORY_DIR/exe/value_tagger$EXE_END
target=$TMP/using_varsilator$EXE_END
; variables in the source get resolved at packing time.
; variables in the target get resolved during unbundling time.

[absolute_path]
source=$REPOSITORY_DIR/exe/nechung$EXE_END
target=/tmp/spoonbender/nechung$EXE_END
; simple file copy to an absolute path.

[wildcard_congelio]
source=$REPOSITORY_DIR/source/test_src/library/t_basis/*
target=$TARGET/muse_files
; wildcards are supported.  this will put all the files from that directory
; "t_basis" into the target in a folder called "muse_files".

[wildcard_specific]
source=$REPOSITORY_DIR/source/lib_src/library/basis/*.h
target=$TARGET/basis_headers
; this is a more specific wildcard that tests a pattern on the end, rather
; than the "get everything" of a bare asterisk.

[recursing_doodle]
source=$REPOSITORY_DIR/source/lib_src/library
target=$TARGET/srcpack/doodle_src
recurse=1
; this shows a recursive copy of the directory "lib_src" into a new directory
; on the target called "doodle_src".  this matches the last component of the
; source directly to the last component of the target, so that the files
; in doodle will show up under doodle_src.
; the flag "recurse" must also be set in the section.  if it has any contents
; besides zero ("0") or "false", then it will be evaluated as enabling
; recursion.  it should not be an empty string (since that is equivalent to it
; not being set at all).
; currently, recursion and wildcards cannot be mixed.

[execute_source_side]
source=$REPOSITORY_DIR/exe/nechung$EXE_END
exec_source=true
no_pack=true
; this is an example of having a source side file be executed (the
; "exec_source" item in the section specifies this).  the file will be
; executed on the source side while the bundle is being packed.  the "no_pack"
; flag means that the source exe will not even be copied to the target
; location.  when this particular item is hit on the source side, nechung will
; be executed and a fortune will be displayed if the database is accessible.

[execute_target_side]
source=$REPOSITORY_DIR/exe/bytedump$EXE_END
target=$TARGET/meldrick$EXE_END
exec_target=true
parms="$TARGET/srcpack/doodle_src/library/basis/trap_new.addin"
; this is an example of a target side executable.  note that we are providing
; a set of parameters to this exe, each of which should be quoted and separated
; by spaces from the next parameter.  note that when this bundle is unpacked,
; there will be a spew of byte data from this command.

[target_exec_sans_source]
target=$TARGET/bytedunker$EXE_END
; the bytedunker application is copied in a previous step.
exec_target=true
no_pack=true
parms="$TARGET/srcpack/doodle_src/library/data_struct/makefile"
; this is an example of a target side executable where the source is not 
; specified and no_pack is used.  this means that the target app must already
; exist in the target location.

[error_check]
source=$REPOSITORY_DIR/exe/bytedump$EXE_END
target=$TARGET/pungentina$EXE_END
exec_target=true
no_pack=true
parms="this" "command will fail" "because it won't be created"
error_okay = true
; shows how the "error_okay" flag can be used to keep a failed run of
; an executable program from stopping the unbundling process.

[no_replacement]
source=$REPOSITORY_DIR/build.ini
target=$TARGET/buildonia.ini
no_replace=true
; this shows how the "no_replace" macro will avoid overwriting a file if it
; already exists.  this emulates the non-overwriting style of copy that most
; installers support.
; to test this option out, run the example app you create to a particular
; directory, then edit the installed version of buildonia.ini to change it
; around, and run the same app again on the same directory.  the result
; should be that your changes are kept.