/*
* call-seq:
* exists(PATH) -> boolean
*
* Return true if there is an entry for this path, false otherwise
*/
VALUE augeas_exists(VALUE s, VALUE path) {
augeas *aug = aug_handle(s);
const char *cpath = StringValueCStr(path);
int ret = aug_get(aug, cpath, NULL);
return (ret == 1) ? Qtrue : Qfalse;
}
VALUE augeas_span(VALUE s, VALUE path) {
augeas *aug = aug_handle(s);
char *cpath = StringValueCStr(path);
char *filename = NULL;
unsigned int label_start, label_end, value_start, value_end,
span_start, span_end;
int r;
VALUE result;
r = aug_span(aug, cpath,
&filename,
&label_start, &label_end,
&value_start, &value_end,
&span_start, &span_end);
result = rb_hash_new();
if (r == 0) {
hash_set(result, "filename", rb_str_new2(filename));
hash_set_range(result, "label", label_start, label_end);
hash_set_range(result, "value", value_start, value_end);
hash_set_range(result, "span", span_start, span_end);
}
free(filename);
return result;
}
/*
* call-seq:
* rm(PATH) -> int
*
* Remove path and all its children. Returns the number of entries removed
*/
VALUE augeas_rm(VALUE s, VALUE path, VALUE sibling) {
augeas *aug = aug_handle(s);
const char *cpath = StringValueCStr(path) ;
int callValue = aug_rm(aug, cpath) ;
return INT2FIX(callValue) ;
}
/*
* call-seq:
* error -> HASH
*
* Retrieve details about the last error encountered and return those
* details in a HASH with the following entries:
* - :code error code from +aug_error+
* - :message error message from +aug_error_message+
* - :minor minor error message from +aug_minor_error_message+
* - :details error details from +aug_error_details+
*/
VALUE augeas_error(VALUE s) {
augeas *aug = aug_handle(s);
int code;
const char *msg;
VALUE result;
result = rb_hash_new();
code = aug_error(aug);
hash_set(result, "code", INT2NUM(code));
msg = aug_error_message(aug);
if (msg != NULL)
hash_set(result, "message", rb_str_new2(msg));
msg = aug_error_minor_message(aug);
if (msg != NULL)
hash_set(result, "minor", rb_str_new2(msg));
msg = aug_error_details(aug);
if (msg != NULL)
hash_set(result, "details", rb_str_new2(msg));
return result;
}
static int set(VALUE s, VALUE path, VALUE value) {
augeas *aug = aug_handle(s);
const char *cpath = StringValueCStr(path) ;
const char *cvalue = StringValueCStrOrNull(value) ;
return aug_set(aug, cpath, cvalue) ;
}
VALUE augeas_close (VALUE s) {
augeas *aug = aug_handle(s);
aug_close(aug);
DATA_PTR(s) = NULL;
return Qnil;
}
/*
* call-seq:
* rename(SRC, LABEL) -> int
*
* Rename the label of all nodes matching SRC to LABEL.
*
* Returns +false+ if +aug_rename+ fails, and the number of nodes renamed
* on success.
*/
VALUE augeas_rename(VALUE s, VALUE src, VALUE label) {
augeas *aug = aug_handle(s);
const char *csrc = StringValueCStr(src);
const char *clabel = StringValueCStr(label);
int r = aug_rename(aug, csrc, clabel);
return (r < 0) ? Qfalse : INT2NUM(r);
}
/*
* call-seq:
* mv(SRC, DST) -> int
*
* Move the node SRC to DST. SRC must match exactly one node in the
* tree. DST must either match exactly one node in the tree, or may not
* exist yet. If DST exists already, it and all its descendants are
* deleted. If DST does not exist yet, it and all its missing ancestors are
* created.
*/
VALUE augeas_mv(VALUE s, VALUE src, VALUE dst) {
augeas *aug = aug_handle(s);
const char *csrc = StringValueCStr(src);
const char *cdst = StringValueCStr(dst);
int r = aug_mv(aug, csrc, cdst);
return INT2FIX(r);
}
/*
* call-seq:
* insert(PATH, LABEL, BEFORE) -> int
*
* Make LABEL a sibling of PATH by inserting it directly before or after PATH.
* The boolean BEFORE determines if LABEL is inserted before or after PATH.
*/
VALUE augeas_insert(VALUE s, VALUE path, VALUE label, VALUE before) {
augeas *aug = aug_handle(s);
const char *cpath = StringValueCStr(path) ;
const char *clabel = StringValueCStr(label) ;
int callValue = aug_insert(aug, cpath, clabel, RTEST(before));
return INT2FIX(callValue) ;
}
/*
* call-seq:
* defvar(NAME, EXPR) -> boolean
*
* Define a variable NAME whose value is the result of evaluating EXPR. If
* a variable NAME already exists, its name will be replaced with the
* result of evaluating EXPR.
*
* If EXPR is NULL, the variable NAME will be removed if it is defined.
*
*/
VALUE augeas_defvar(VALUE s, VALUE name, VALUE expr) {
augeas *aug = aug_handle(s);
const char *cname = StringValueCStr(name);
const char *cexpr = StringValueCStrOrNull(expr);
int r = aug_defvar(aug, cname, cexpr);
return (r < 0) ? Qfalse : Qtrue;
}
/*
* call-seq:
* setm(BASE, SUB, VALUE) -> boolean
*
* Set multiple nodes in one operation. Find or create a node matching
* SUB by interpreting SUB as a path expression relative to each node
* matching BASE. SUB may be NULL, in which case all the nodes matching
* BASE will be modified.
*/
VALUE augeas_setm(VALUE s, VALUE base, VALUE sub, VALUE value) {
augeas *aug = aug_handle(s);
const char *cbase = StringValueCStr(base) ;
const char *csub = StringValueCStrOrNull(sub) ;
const char *cvalue = StringValueCStrOrNull(value) ;
int callValue = aug_setm(aug, cbase, csub, cvalue) ;
return INT2FIX(callValue);
}
/*
* call-seq:
* text_store(LENS, NODE, PATH) -> boolean
*
* Use the value of node NODE as a string and transform it into a tree
* using the lens LENS and store it in the tree at PATH, which will be
* overwritten. PATH and NODE are path expressions.
*/
VALUE augeas_text_store(VALUE s, VALUE lens, VALUE node, VALUE path) {
augeas *aug = aug_handle(s);
const char *clens = StringValueCStr(lens);
const char *cnode = StringValueCStr(node);
const char *cpath = StringValueCStr(path);
int r = aug_text_store(aug, clens, cnode, cpath);
return (r < 0) ? Qfalse : Qtrue;
}
/*
* call-seq:
* text_retrieve(LENS, NODE_IN, PATH, NODE_OUT) -> boolean
*
* Transform the tree at PATH into a string using lens LENS and store it in
* the node NODE_OUT, assuming the tree was initially generated using the
* value of node NODE_IN. PATH, NODE_IN, and NODE_OUT are path expressions.
*/
VALUE augeas_text_retrieve(VALUE s, VALUE lens, VALUE node_in, VALUE path, VALUE node_out) {
augeas *aug = aug_handle(s);
const char *clens = StringValueCStr(lens);
const char *cnode_in = StringValueCStr(node_in);
const char *cpath = StringValueCStr(path);
const char *cnode_out = StringValueCStr(node_out);
int r = aug_text_retrieve(aug, clens, cnode_in, cpath, cnode_out);
return (r < 0) ? Qfalse : Qtrue;
}
/*
* call-seq:
* load() -> boolean
*
* Load files from disk according to the transforms under +/augeas/load+
*/
VALUE augeas_load(VALUE s) {
augeas *aug = aug_handle(s);
int callValue = aug_load(aug);
VALUE returnValue ;
if (callValue == 0)
returnValue = Qtrue ;
else
returnValue = Qfalse ;
return returnValue ;
}
/*
* call-seq:
* defnode(NAME, EXPR, VALUE) -> boolean
*
* Define a variable NAME whose value is the result of evaluating EXPR,
* which must be non-NULL and evaluate to a nodeset. If a variable NAME
* already exists, its name will be replaced with the result of evaluating
* EXPR.
*
* If EXPR evaluates to an empty nodeset, a node is created, equivalent to
* calling AUG_SET(AUG, EXPR, VALUE) and NAME will be the nodeset containing
* that single node.
*
* Returns +false+ if +aug_defnode+ fails, and the number of nodes in the
* nodeset on success.
*/
VALUE augeas_defnode(VALUE s, VALUE name, VALUE expr, VALUE value) {
augeas *aug = aug_handle(s);
const char *cname = StringValueCStr(name);
const char *cexpr = StringValueCStrOrNull(expr);
const char *cvalue = StringValueCStrOrNull(value);
/* FIXME: Figure out a way to return created, maybe accept a block
that gets run when created == 1 ? */
int r = aug_defnode(aug, cname, cexpr, cvalue, NULL);
return (r < 0) ? Qfalse : INT2NUM(r);
}
/*
* call-seq:
* label(PATH) -> String
*
* Lookup the label associated with PATH
*/
VALUE augeas_label(VALUE s, VALUE path) {
augeas *aug = aug_handle(s);
const char *cpath = StringValueCStr(path);
const char *label;
aug_label(aug, cpath, &label);
if (label != NULL) {
return rb_str_new(label, strlen(label)) ;
} else {
return Qnil;
}
}
/*
* call-seq:
* get(PATH) -> String
*
* Lookup the value associated with PATH
*/
VALUE augeas_get(VALUE s, VALUE path) {
augeas *aug = aug_handle(s);
const char *cpath = StringValueCStr(path);
const char *value;
aug_get(aug, cpath, &value);
if (value != NULL) {
return rb_str_new(value, strlen(value)) ;
} else {
return Qnil;
}
}
/*
* call-seq:
* set(PATH, VALUE) -> boolean
*
* Set the value associated with PATH to VALUE. VALUE is copied into the
* internal data structure. Intermediate entries are created if they don't
* exist.
*/
VALUE augeas_set(VALUE s, VALUE path, VALUE value) {
augeas *aug = aug_handle(s);
const char *cpath = StringValueCStr(path) ;
const char *cvalue = StringValueCStrOrNull(value) ;
int callValue = aug_set(aug, cpath, cvalue) ;
VALUE returnValue ;
if (callValue == 0)
returnValue = Qtrue ;
else
returnValue = Qfalse ;
return returnValue ;
}
/*
* call-seq:
* get(PATH) -> String
*
* Lookup the value associated with PATH
*/
VALUE augeas_get(VALUE s, VALUE path) {
augeas *aug = aug_handle(s);
const char *cpath = StringValueCStr(path);
const char *value = NULL;
int r = aug_get(aug, cpath, &value);
/* There used to be a bug in Augeas that would make it not properly set
* VALUE to NULL when PATH was invalid. We check RETVAL, too, to avoid
* running into that */
if (r == 1 && value != NULL) {
return rb_str_new(value, strlen(value)) ;
} else {
return Qnil;
}
}
/*
* call-seq:
* srun(COMMANDS) -> [int, String]
*
* Run one or more newline-separated commands, returning their output.
*
* Returns:
* an array where the first element is the number of executed commands on
* success, -1 on failure, and -2 if a 'quit' command was encountered.
* The second element is a string of the output from all commands.
*/
VALUE augeas_srun(VALUE s, VALUE text) {
augeas *aug = aug_handle(s);
const char *ctext = StringValueCStr(text);
struct memstream ms;
__aug_init_memstream(&ms);
int r = aug_srun(aug, ms.stream, ctext);
__aug_close_memstream(&ms);
VALUE result = rb_ary_new();
rb_ary_push(result, INT2NUM(r));
rb_ary_push(result, rb_str_new2(ms.buf));
free(ms.buf);
return result;
}
/*
* call-seq:
* match(PATH) -> an_array
*
* Return all the paths that match the path expression PATH as an aray of
* strings.
*/
VALUE augeas_match(VALUE s, VALUE p) {
augeas *aug = aug_handle(s);
const char *path = StringValueCStr(p);
char **matches = NULL;
int cnt, i;
cnt = aug_match(aug, path, &matches) ;
if (cnt < 0)
rb_raise(rb_eSystemCallError, "Matching path expression '%s' failed",
path);
VALUE result = rb_ary_new();
for (i = 0; i < cnt; i++) {
rb_ary_push(result, rb_str_new(matches[i], strlen(matches[i])));
free(matches[i]) ;
}
free (matches) ;
return result ;
}
/*
* call-seq:
* match(PATH) -> an_array
*
* Return all the paths that match the path expression PATH as an aray of
* strings.
* Returns an empty array if no paths were found.
*/
VALUE facade_match(VALUE s, VALUE p) {
augeas *aug = aug_handle(s);
const char *path = StringValueCStr(p);
char **matches = NULL;
int cnt, i;
VALUE result;
cnt = aug_match(aug, path, &matches) ;
if (cnt < 0)
return -1;
result = rb_ary_new();
for (i = 0; i < cnt; i++) {
rb_ary_push(result, rb_str_new(matches[i], strlen(matches[i])));
free(matches[i]) ;
}
free (matches) ;
return result ;
}
/*
* call-seq:
* save() -> boolean
*
* Write all pending changes to disk
*/
VALUE augeas_save(VALUE s) {
augeas *aug = aug_handle(s);
return (aug_save(aug) == 0) ? Qtrue : Qfalse;
}
/*
* call-seq:
* save() -> int
*
* Write all pending changes to disk
*/
VALUE facade_save(VALUE s) {
augeas *aug = aug_handle(s);
return INT2FIX(aug_save(aug));
}
