time-to-botec/js/node_modules/@stdlib/utils/library-manifest

Manifest

Load a manifest for compiling source files.

Usage

var manifest = require( '@stdlib/utils/library-manifest' );

manifest( filepath, conditions[, options] )

Loads a manifest for compiling source files.

var conditions = {
    'os': 'linux'
};

var conf = manifest( './examples/manifest.json', conditions );
// returns <Object>

The function accepts the following options:

• basedir: base directory from which to search for dependencies. Default: current working directory.
• paths: path convention. Must be either 'win32', 'mixed', or 'posix'. Default: based on host platform.

The default search directory is the current working directory of the calling process. To specify an alternative search directory, set the basedir option.

var conditions = {
    'os': 'linux'
};

var opts = {
    'basedir': __dirname
};

var conf = manifest( './examples/manifest.json', conditions, opts );
// returns <Object>

Notes

• A manifest is a JSON file having the following fields:

  • options: an object containing key-value pairs. Each key corresponds to a field in confs and may be used to conditionally select a configuration. Each value corresponds to the key's default value. The value for each field in a provided conditions object which has a corresponding field in options overrides the default value.

    Option keys are akin to primary keys in relational databases, in the sense that they should be used to uniquely identify a particular configuration. While individual key values may be shared across configurations, each configuration should have a unique combination of key values. Furthermore, default option values considered as a unique set should identify one and only one default configuration.

  • fields: an object array where each object has the following fields:

    • field: key name corresponding to a field in confs.
    • resolve: boolean indicating whether to resolve field values as file paths. If true, all field values are resolved relative to the manifest file.
    • relative: boolean indicating whether to resolve field values as relative file paths. This field is only considered when a manifest is a root manifest. If true, all field values, including those originating from dependencies, are resolved as relative file paths relative the root manifest.

  • confs: an object array where each object corresponds to a manifest configuration. Each object has the following fields:

    • src: array of source files.
    • include: array of include directories.
    • libraries: array of linked library dependencies.
    • libpath: array of linked library paths.
    • dependencies: array of package dependencies containing source files.

  An example manifest:

  {
    "options": {
      "os": "linux"
    },
    "fields": [
      {
        "field": "src",
        "resolve": true,
        "relative": true
      },
      {
        "field": "include",
        "resolve": true,
        "relative": false
      },
      {
        "field": "libraries",
        "resolve": false,
        "relative": false
      },
      {
        "field": "libpath",
        "resolve": true,
        "relative": false
      }
    ],
    "confs": [
      {
        "os": "linux",
        "src": [
          "./src/foo_linux.f",
          "./src/foo_linux.c"
        ],
        "include": [
          "./include"
        ],
        "libraries": [],
        "libpath": [],
        "dependencies": [
          "@stdlib/blas/base/daxpy",
          "@stdlib/blas/base/dasum",
          "@stdlib/blas/base/dcopy"
        ]
      }
    ]
  }   
  

• The function recursively walks the manifest dependency tree to resolve all source files, libraries, library paths, and include directories.

• An input filepath may be either a relative or absolute file path. If provided a relative file path, a manifest is resolved relative to the base search directory.

• If a conditions object contains fields which do not correspond to manifest options, those fields are ignored (i.e., the "extra" fields have no effect when filtering manifest configurations). This allows providing a conditions object containing fields which only apply to certain subsets of manifest dependencies.

• If no fields in a conditions object have corresponding fields in a manifest's options, the function returns a manifest's default configuration.

Examples

var join = require( 'path' ).join;
var manifest = require( '@stdlib/utils/library-manifest' );

// Resolve the absolute path of the manifest JSON file:
var fpath = join( __dirname, 'examples', 'manifest.json' );

// Specify conditions for determining which configuration to load:
var conditions = {
    'os': 'mac'
};

// Specify options:
var opts = {
    'basedir': __dirname
};

// Load a manifest configuration:
var conf = manifest( fpath, conditions, opts );
console.dir( conf );

---

CLI

Usage

Usage: library-manifest [options] <filepath> [-- --<condition>=value ...]

Options:

  -h,    --help                Print this message.
  -V,    --version             Print the package version.
         --dir basedir         Base search directory.
         --paths convention    Path convention.

Notes

• Use command-line flags to specify conditions by placing them after a -- separator.

Examples

$ library-manifest ./examples/manifest.json -- --os mac