ruby-augeas 0.4.1 → 0.6.0

data/ext/augeas/_augeas.c

@@ -1,7 +1,7 @@
 /*
  * augeas.c: Ruby bindings for augeas
  *
- * Copyright (C) 2008 Red Hat Inc.
+ * Copyright (C) 2008-2011 Red Hat Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -19,13 +19,13 @@
  *
  * Author: Bryan Kearney <bkearney@redhat.com>
  */
+#include "_augeas.h"
+
 #include <ruby.h>
 #include <augeas.h>
 
 static VALUE c_augeas;
-
-#define StringValueCStrOrNull(v)                \
-    NIL_P(v) ? NULL : StringValueCStr(v)
+static VALUE c_facade;
 
 static augeas *aug_handle(VALUE s) {
     augeas *aug;
@@ -51,16 +51,39 @@ static void augeas_free(augeas *aug) {
 VALUE augeas_get(VALUE s, VALUE path) {
     augeas *aug = aug_handle(s);
     const char *cpath = StringValueCStr(path);
-    const char *value;
+    const char *value = NULL;
 
-    aug_get(aug, cpath, &value);
-    if (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:
+ *   get(PATH) -> String
+ *
+ * Lookup the value associated with PATH
+ */
+VALUE facade_get(VALUE s, VALUE path) {
+    augeas *aug = aug_handle(s);
+    const char *cpath = StringValueCStr(path);
+    const char *value = NULL;
+
+    int retval = aug_get(aug, cpath, &value);
+
+    if (retval == 1 && value != NULL) {
+        return rb_str_new(value, strlen(value));
+    } else {
+        return Qnil;
+    }
+}
+
 /*
  * call-seq:
  *   exists(PATH) -> boolean
@@ -75,28 +98,30 @@ VALUE augeas_exists(VALUE s, VALUE path) {
     return (ret == 1) ? Qtrue : Qfalse;
 }
 
+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) ;
+}
+
 /*
  * call-seq:
- *   set(PATH, VALUE) -> boolean
+ *   set(PATH, VALUE) -> int
  *
  * 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 = set(s, path, value);
 
-    int callValue = aug_set(aug, cpath, cvalue) ;
-    VALUE returnValue ;
-
-    if (callValue == 0)
-        returnValue = Qtrue ;
-    else
-        returnValue = Qfalse ;
+    return (callValue == 0) ? Qtrue : Qfalse;
+}
 
-    return returnValue ;
+VALUE facade_set(VALUE s, VALUE path, VALUE value) {
+    return INT2FIX(set(s, path, value));
 }
 
 /*
@@ -159,7 +184,7 @@ VALUE augeas_mv(VALUE s, VALUE src, VALUE dst) {
  *
  * Remove path and all its children. Returns the number of entries removed
  */
-VALUE augeas_rm(VALUE s, VALUE path, VALUE sibling) {
+VALUE augeas_rm(VALUE s, VALUE path) {
     augeas *aug = aug_handle(s);
     const char *cpath = StringValueCStr(path) ;
 
@@ -177,6 +202,7 @@ VALUE augeas_rm(VALUE s, VALUE path, VALUE sibling) {
 VALUE augeas_match(VALUE s, VALUE p) {
     augeas *aug = aug_handle(s);
     const char *path = StringValueCStr(p);
+    VALUE result;
     char **matches = NULL;
     int cnt, i;
 
@@ -185,7 +211,36 @@ VALUE augeas_match(VALUE s, VALUE p) {
         rb_raise(rb_eSystemCallError, "Matching path expression '%s' failed",
                  path);
 
-    VALUE result = rb_ary_new();
+    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]) ;
@@ -203,15 +258,19 @@ VALUE augeas_match(VALUE s, VALUE p) {
  */
 VALUE augeas_save(VALUE s) {
     augeas *aug = aug_handle(s);
-    int callValue = aug_save(aug) ;
-    VALUE returnValue ;
 
-    if (callValue == 0)
-        returnValue = Qtrue ;
-    else
-        returnValue = Qfalse ;
+    return (aug_save(aug) == 0) ? Qtrue : Qfalse;
+}
 
-    return returnValue ;
+/*
+ * 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));
 }
 
 /*
@@ -283,7 +342,7 @@ VALUE augeas_defnode(VALUE s, VALUE name, VALUE expr, VALUE value) {
     return (r < 0) ? Qfalse : INT2NUM(r);
 }
 
-VALUE augeas_init(VALUE m, VALUE r, VALUE l, VALUE f) {
+static VALUE init(VALUE class, VALUE m, VALUE r, VALUE l, VALUE f) {
     unsigned int flags = NUM2UINT(f);
     const char *root = StringValueCStrOrNull(r);
     const char *loadpath = StringValueCStrOrNull(l);
@@ -293,7 +352,15 @@ VALUE augeas_init(VALUE m, VALUE r, VALUE l, VALUE f) {
     if (aug == NULL) {
         rb_raise(rb_eSystemCallError, "Failed to initialize Augeas");
     }
-    return Data_Wrap_Struct(c_augeas, NULL, augeas_free, aug);
+    return Data_Wrap_Struct(class, NULL, augeas_free, aug);
+}
+
+VALUE augeas_init(VALUE m, VALUE r, VALUE l, VALUE f) {
+    return init(c_augeas, m, r, l, f);
+}
+
+VALUE facade_init(VALUE m, VALUE r, VALUE l, VALUE f) {
+    return init(c_facade, m, r, l, f);
 }
 
 VALUE augeas_close (VALUE s) {
@@ -383,10 +450,117 @@ VALUE augeas_span(VALUE s, VALUE path) {
     return result;
 }
 
+/*
+ * 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);
+    int r;
+    VALUE result;
+    struct memstream ms;
+    __aug_init_memstream(&ms);
+
+    r = aug_srun(aug, ms.stream, ctext);
+    __aug_close_memstream(&ms);
+
+    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:
+ *   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:
+ *   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:
+ *   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;
+}
+
 void Init__augeas() {
 
     /* Define the ruby class */
     c_augeas = rb_define_class("Augeas", rb_cObject) ;
+    rb_undef_alloc_func(c_augeas);
+    c_facade = rb_define_class_under(c_augeas, "Facade", rb_cObject);
+    rb_undef_alloc_func(c_facade);
 
     /* Constants for enum aug_flags */
 #define DEF_AUG_FLAG(name) \
@@ -414,6 +588,11 @@ void Init__augeas() {
     DEF_AUG_ERR(ESYNTAX);
     DEF_AUG_ERR(ENOLENS);
     DEF_AUG_ERR(EMXFM);
+    DEF_AUG_ERR(ENOSPAN);
+    DEF_AUG_ERR(EMVDESC);
+    DEF_AUG_ERR(ECMDRUN);
+    DEF_AUG_ERR(EBADARG);
+    DEF_AUG_ERR(ELABEL);
 #undef DEF_AUG_ERR
 
     /* Define the methods */
@@ -433,6 +612,35 @@ void Init__augeas() {
     rb_define_method(c_augeas, "close", augeas_close, 0);
     rb_define_method(c_augeas, "error", augeas_error, 0);
     rb_define_method(c_augeas, "span", augeas_span, 1);
+    rb_define_method(c_augeas, "srun", augeas_srun, 1);
+    rb_define_method(c_augeas, "label", augeas_label, 1);
+    rb_define_method(c_augeas, "rename", augeas_rename, 2);
+    rb_define_method(c_augeas, "text_store", augeas_text_store, 3);
+    rb_define_method(c_augeas, "text_retrieve", augeas_text_retrieve, 4);
+
+    /* Define methods to support the 'new' API in Augeas::Facade */
+    rb_define_singleton_method(c_facade, "open3", facade_init, 3);
+    /* The `close` and `error` methods as used unchanged in the ruby bindings */
+    rb_define_method(c_facade, "close", augeas_close, 0);
+    rb_define_method(c_facade, "error", augeas_error, 0);
+    rb_define_method(c_facade, "augeas_defvar", augeas_defvar, 2);
+    rb_define_method(c_facade, "augeas_defnode", augeas_defnode, 3);
+    rb_define_method(c_facade, "augeas_get", augeas_get, 1);
+    rb_define_method(c_facade, "augeas_exists", augeas_exists, 1);
+    rb_define_method(c_facade, "augeas_insert", augeas_insert, 3);
+    rb_define_method(c_facade, "augeas_mv", augeas_mv, 2);
+    rb_define_method(c_facade, "augeas_rm", augeas_rm, 1);
+    rb_define_method(c_facade, "augeas_match", facade_match, 1);
+    rb_define_method(c_facade, "augeas_save", facade_save, 0);
+    rb_define_method(c_facade, "augeas_load", augeas_load, 0);
+    rb_define_method(c_facade, "augeas_set", facade_set, 2);
+    rb_define_method(c_facade, "augeas_setm", augeas_setm, 3);
+    rb_define_method(c_facade, "augeas_span", augeas_span, 1);
+    rb_define_method(c_facade, "augeas_srun", augeas_srun, 1);
+    rb_define_method(c_facade, "augeas_label", augeas_label, 1);
+    rb_define_method(c_facade, "augeas_rename", augeas_rename, 2);
+    rb_define_method(c_facade, "augeas_text_store", augeas_text_store, 3);
+    rb_define_method(c_facade, "augeas_text_retrieve", augeas_text_retrieve, 4);
 }
 
 /*

data/ext/augeas/_augeas.h

@@ -0,0 +1,48 @@
+/*
+ * augeas.h: internal headers for Augeas Ruby bindings
+ *
+ * Copyright (C) 2008-2011 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include <ruby.h>
+
+#ifndef _AUGEAS_H_
+#define _AUGEAS_H_
+
+#define StringValueCStrOrNull(v)                \
+    NIL_P(v) ? NULL : StringValueCStr(v)
+
+/* memstream support from Augeas internal.h */
+struct memstream {
+    FILE   *stream;
+    char   *buf;
+    size_t size;
+};
+
+int __aug_init_memstream(struct memstream *ms);
+int __aug_close_memstream(struct memstream *ms);
+
+#endif
+
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */

data/ext/augeas/extconf.rb

@@ -27,4 +27,8 @@ unless pkg_config("augeas")
     raise "augeas-devel not installed"
 end
 
+unless pkg_config("libxml-2.0")
+    raise "libxml2-devel not installed"
+end
+
 create_makefile(extension_name)