Class: Augeas

Inherits:
Object
  • Object
show all
Defined in:
lib/augeas.rb,
ext/augeas/_augeas.c

Overview

Wrapper class for the augeas library.

Defined Under Namespace

Classes: CommandExecutionError, DescendantError, Error, Facade, InternalError, InvalidArgumentError, InvalidLabelError, InvalidPathError, LensNotFoundError, LensSyntaxError, MultipleMatchesError, MultipleTransformsError, NoMatchError, NoMemoryError, NoSpanInfoError

Constant Summary collapse

ERRORS_HASH = 
Hash[{
	# the cryptic error names come from the C library, we just make
	# them more ruby and more human
	:ENOMEM    => NoMemoryError,
	:EINTERNAL => InternalError,
	:EPATHX    => InvalidPathError,
	:ENOMATCH  => NoMatchError,
	:EMMATCH   => MultipleMatchesError,
	:ESYNTAX   => LensSyntaxError,
	:ENOLENS   => LensNotFoundError,
	:EMXFM     => MultipleTransformsError,
	:ENOSPAN   => NoSpanInfoError,
	:EMVDESC   => DescendantError,
	:ECMDRUN   => CommandExecutionError,
	:EBADARG   => InvalidArgumentError,
	:ELABEL    => InvalidLabelError,
}.map { |k, v| [(const_get(k) rescue nil), v] }].freeze

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.create(opts = {}, &block) ⇒ Object

Use :root as the filesystem root. If :root is nil, use the value of the environment variable AUGEAS_ROOT. If that doesn't exist either, use "/".

:loadpath is a colon-spearated list of directories that modules should be searched in. This is in addition to the standard load path and the directories in AUGEAS_LENS_LIB

The following flags can be specified in a hash. They all default to false and can be enabled by setting them to true

:type_check - typecheck lenses (since it can be very expensive it is not done by default)

:no_stdinc - do not use the builtin load path for modules

:no_load - do not load the tree during the initialization phase

:no_modl_autoload - do not load the tree during the initialization phase

:enable_span - track the span in the input nodes

:save_mode can be one of :backup, :newfile, :noop as explained below.

:noop - make save a no-op process, just record what would have changed

:backup - keep the original file with an .augsave extension

:newfile - save changes into a file with an .augnew extension and
do not overwrite the original file.

When a block is given, the Augeas instance is passed as the only argument into the block and closed when the block exits. With no block, the Augeas instance is returned.



98
99
100
 
# File 'lib/augeas.rb', line 98

def self.create(opts={}, &block)
  Augeas::Facade::create(opts, &block)
end

.open(root = nil, loadpath = nil, flags = NONE, &block) ⇒ Object

Create a new Augeas instance and return it.

Use root as the filesystem root. If root is nil, use the value of the environment variable AUGEAS_ROOT. If that doesn't exist either, use "/".

loadpath is a colon-spearated list of directories that modules should be searched in. This is in addition to the standard load path and the directories in AUGEAS_LENS_LIB

flags is a bitmask (see enum aug_flags)

When a block is given, the Augeas instance is passed as the only argument into the block and closed when the block exits. In that case, the return value of the block is the return value of open. With no block, the Augeas instance is returned.



118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/augeas.rb', line 118

def self.open(root = nil, loadpath = nil, flags = NONE, &block)
    aug = open3(root, loadpath, flags)
    if block_given?
        begin
            rv = yield aug
            return rv
        ensure
            aug.close
        end
    else
        return aug
    end
end

.open3(r, l, f) ⇒ Object

Define the methods



358
359
360
 
# File 'ext/augeas/_augeas.c', line 358

VALUE augeas_init(VALUE m, VALUE r, VALUE l, VALUE f) {
    return init(c_augeas, m, r, l, f);
}

Instance Method Details

#clear(path) ⇒ Object

Clear the path, i.e. make its value nil



147
148
149
 
# File 'lib/augeas.rb', line 147

def clear(path)
    set_internal(path, nil)
end

#clear_transforms ⇒ Object

Clear all transforms under /augeas/load. If load is called right after this, there will be no files under /files



166
167
168
 
# File 'lib/augeas.rb', line 166

def clear_transforms
    rm("/augeas/load/*")
end

#clearm(base, sub) ⇒ Object

Clear multiple nodes values in one operation. Find or create a node matching sub by interpreting sub as a path expression relative to each node matching base. If sub is '.', the nodes matching base will be modified.



154
155
156
 
# File 'lib/augeas.rb', line 154

def clearm(base, sub)
    setm(base, sub, nil)
end

#close ⇒ Object 



366
367
368
369
370
371
372
373
 
# File 'ext/augeas/_augeas.c', line 366

VALUE augeas_close (VALUE s) {
    augeas *aug = aug_handle(s);

    aug_close(aug);
    DATA_PTR(s) = NULL;

    return Qnil;
}

#context ⇒ Object

Get path expression context (from /augeas/context)



209
210
211
 
# File 'lib/augeas.rb', line 209

def context
  get('/augeas/context')
end

#context=(path) ⇒ Object

Set path expression context to path (in /augeas/context)



204
205
206
 
# File 'lib/augeas.rb', line 204

def context=(path)
  set_internal('/augeas/context', path)
end

#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.

Returns:

  • (Boolean) 


332
333
334
335
336
337
338
339
340
341
342
343
 
# File 'ext/augeas/_augeas.c', line 332

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);
}

#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.

Returns:

  • (Boolean) 


306
307
308
309
310
311
312
313
314
 
# File 'ext/augeas/_augeas.c', line 306

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;
}

#error ⇒ Object

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


390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
 
# File 'ext/augeas/_augeas.c', line 390

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;
}

#exists(PATH) ⇒ Boolean

Return true if there is an entry for this path, false otherwise

Returns:

  • (Boolean) 


93
94
95
96
97
98
99
 
# File 'ext/augeas/_augeas.c', line 93

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;
}

#get(PATH) ⇒ String

Lookup the value associated with PATH

Returns:

  • (String) 


51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'ext/augeas/_augeas.c', line 51

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;
    }
}

#insert(PATH, LABEL, BEFORE) ⇒ Integer

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.

Returns:

  • (Integer) 


153
154
155
156
157
158
159
160
 
# File 'ext/augeas/_augeas.c', line 153

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) ;
}

#label(PATH) ⇒ String

Lookup the label associated with PATH

Returns:

  • (String) 


489
490
491
492
493
494
495
496
497
498
499
500
 
# File 'ext/augeas/_augeas.c', line 489

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;
    }
}

#load ⇒ Boolean

Load files from disk according to the transforms under /augeas/load

Returns:

  • (Boolean) 


282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'ext/augeas/_augeas.c', line 282

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 ;
}

#load! ⇒ Object

The same as load, but raises Augeas::Error if loading fails

Raises:



199
200
201
 
# File 'lib/augeas.rb', line 199

def load!
    raise Augeas::Error unless load
end

#match(PATH) ⇒ Array

Return all the paths that match the path expression PATH as an aray of strings.

Returns:

  • (Array) 


202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'ext/augeas/_augeas.c', line 202

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;

    cnt = aug_match(aug, path, &matches) ;
    if (cnt < 0)
        rb_raise(rb_eSystemCallError, "Matching path expression '%s' failed",
                 path);

    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 ;
}

#mv(SRC, DST) ⇒ Integer

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.

Returns:

  • (Integer) 


172
173
174
175
176
177
178
179
 
# File 'ext/augeas/_augeas.c', line 172

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);
}

#rename(SRC, LABEL) ⇒ Integer

Rename the label of all nodes matching SRC to LABEL.

Returns false if aug_rename fails, and the number of nodes renamed on success.

Returns:

  • (Integer) 


511
512
513
514
515
516
517
518
 
# File 'ext/augeas/_augeas.c', line 511

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);
}

#rm(PATH) ⇒ Integer

Remove path and all its children. Returns the number of entries removed

Returns:

  • (Integer) 


187
188
189
190
191
192
193
 
# File 'ext/augeas/_augeas.c', line 187

VALUE augeas_rm(VALUE s, VALUE path) {
    augeas *aug = aug_handle(s);
    const char *cpath = StringValueCStr(path) ;

    int callValue = aug_rm(aug, cpath) ;
    return INT2FIX(callValue) ;
}

#save ⇒ Boolean

Write all pending changes to disk

Returns:

  • (Boolean) 


259
260
261
262
263
 
# File 'ext/augeas/_augeas.c', line 259

VALUE augeas_save(VALUE s) {
    augeas *aug = aug_handle(s);

    return (aug_save(aug) == 0) ? Qtrue : Qfalse;
}

#save! ⇒ Object

The same as save, but raises Augeas::Error if saving fails

Raises:



194
195
196
 
# File 'lib/augeas.rb', line 194

def save!
    raise Augeas::Error unless save
end

#set(path, *values) ⇒ Object

Set one or multiple elemens to path. Multiple elements are mainly sensible with a path like .../array, since this will append all elements.



135
136
137
 
# File 'lib/augeas.rb', line 135

def set(path, *values)
    values.flatten.each { |v| set_internal(path, v) }
end

#set!(path, *values) ⇒ Object

The same as set, but raises Augeas::Error if setting fails



140
141
142
143
144
 
# File 'lib/augeas.rb', line 140

def set!(path, *values)
    values.flatten.each do |v|
        raise Augeas::Error unless set_internal(path, v)
    end
end

#set(PATH, VALUE) ⇒ Integer

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.

Returns:

  • (Integer) 


117
118
119
120
121
 
# File 'ext/augeas/_augeas.c', line 117

VALUE augeas_set(VALUE s, VALUE path, VALUE value) {
    int callValue = set(s, path, value);

    return (callValue == 0) ? Qtrue : Qfalse;
}

#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.

Returns:

  • (Boolean) 


136
137
138
139
140
141
142
143
144
 
# File 'ext/augeas/_augeas.c', line 136

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);
}

#span(path) ⇒ Object 



424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
 
# File 'ext/augeas/_augeas.c', line 424

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;
}

#srun(COMMANDS) ⇒ Array, 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.

Returns ].

Returns:

  • (Array, String) —

    ]



464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
 
# File 'ext/augeas/_augeas.c', line 464

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;
}

#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.

Returns:

  • (Boolean) 


546
547
548
549
550
551
552
553
554
555
 
# File 'ext/augeas/_augeas.c', line 546

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;
}

#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.

Returns:

  • (Boolean) 


528
529
530
531
532
533
534
535
536
 
# File 'ext/augeas/_augeas.c', line 528

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;
}

#touch(path) ⇒ Object

Create the path with empty value if it doesn't exist



159
160
161
 
# File 'lib/augeas.rb', line 159

def touch(path)
    set_internal(path, nil) if match(path).empty?
end

#transform(hash) ⇒ Object

Add a transform under /augeas/load

The HASH can contain the following entries

  • :lens - the name of the lens to use
  • :name - a unique name; use the module name of the LENS when omitted
  • :incl - a list of glob patterns for the files to transform
  • :excl - a list of the glob patterns to remove from the list that matches :INCL

Raises:

  • (ArgumentError) 


177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/augeas.rb', line 177

def transform(hash)
    lens = hash[:lens]
    name = hash[:name]
    incl = hash[:incl]
    excl = hash[:excl]
    raise ArgumentError, "No lens specified" unless lens
    raise ArgumentError, "No files to include" unless incl
    lens = "#{lens}.lns" unless lens.include? '.'
    name = lens.split(".")[0].sub("@", "") unless name

    xfm = "/augeas/load/#{name}/"
    set(xfm + "lens", lens)
    set(xfm + "incl[last()+1]", incl)
    set(xfm + "excl[last()+1]", excl) if excl
end