# class ENV

`ENV` is a hash-like accessor for environment variables.

### Public Class Methods

ENV[name] → value click to toggle source

Retrieves the `value` for environment variable `name` as a `String`. Returns `nil` if the named variable does not exist.

    static VALUE
    rb_f_getenv(VALUE obj, VALUE name)
    {
        const char *nam, *env;

        nam = env_name(name);
        env = getenv(nam);
        if (env) {
            return env_name_new(nam, env);
        }
        return Qnil;
    }

ENV[name] = value click to toggle source

Sets the environment variable `name` to `value`. If the value given is `nil` the environment variable is deleted. `name` must be a string.

    static VALUE
    env_aset(VALUE obj, VALUE nm, VALUE val)
    {
        char *name, *value;

        if (NIL_P(val)) {
            env_delete(obj, nm);
            return Qnil;
        }
        SafeStringValue(nm);
        SafeStringValue(val);
        /* nm can be modified in `val.to_str`, don't get `name` before
         * check for `val` */
        get_env_ptr(name, nm);
        get_env_ptr(value, val);

        ruby_setenv(name, value);
        if (ENVMATCH(name, PATH_ENV)) {
            RB_GC_GUARD(nm);
            if (OBJ_TAINTED(val)) {
                /* already tainted, no check */
                path_tainted = 1;
                return val;
            }
            else {
                path_tainted_p(value);
            }
        }
        else if (ENVMATCH(name, TZ_ENV)) {
            ruby_tz_uptodate_p = FALSE;
        }
        return val;
    }

assoc(name) → Array or nil click to toggle source

Returns an `Array` of the name and value of the environment variable with `name` or `nil` if the name cannot be found.

    static VALUE
    env_assoc(VALUE env, VALUE key)
    {
        const char *s, *e;

        s = env_name(key);
        e = getenv(s);
        if (e) return rb_assoc_new(key, env_str_new2(e));
        return Qnil;
    }

clear click to toggle source

Removes every environment variable.

    VALUE
    rb_env_clear(void)
    {
        VALUE keys;
        long i;

        keys = env_keys();
        for (i=0; i<RARRAY_LEN(keys); i++) {
            VALUE val = rb_f_getenv(Qnil, RARRAY_AREF(keys, i));
            if (!NIL_P(val)) {
                env_delete(Qnil, RARRAY_AREF(keys, i));
            }
        }
        RB_GC_GUARD(keys);
        return envtbl;
    }

delete(name) → value click to toggle source
delete(name) { |name| block } → value

Deletes the environment variable with `name` and returns the value of the variable. If a block is given it will be called when the named environment does not exist.

    static VALUE
    env_delete_m(VALUE obj, VALUE name)
    {
        VALUE val;

        val = env_delete(obj, name);
        if (NIL_P(val) && rb_block_given_p()) rb_yield(name);
        return val;
    }

delete_if { |name, value| block } → Hash click to toggle source
delete_if → Enumerator

Deletes every environment variable for which the block evaluates to `true`.

If no block is given an enumerator is returned instead.

    static VALUE
    env_delete_if(VALUE ehash)
    {
        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
        env_reject_bang(ehash);
        return envtbl;
    }

each { |name, value| block } → Hash click to toggle source
each → Enumerator
each_pair { |name, value| block } → Hash
each_pair → Enumerator

Yields each environment variable `name` and `value`.

If no block is given an `Enumerator` is returned.

    static VALUE
    env_each_pair(VALUE ehash)
    {
        char **env;
        VALUE ary;
        long i;

        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);

        ary = rb_ary_new();
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s) {
                rb_ary_push(ary, env_str_new(*env, s-*env));
                rb_ary_push(ary, env_str_new2(s+1));
            }
            env++;
        }
        FREE_ENVIRON(environ);

        if (rb_block_arity() > 1) {
            for (i=0; i<RARRAY_LEN(ary); i+=2) {
                rb_yield_values(2, RARRAY_AREF(ary, i), RARRAY_AREF(ary, i+1));
            }
        }
        else {
            for (i=0; i<RARRAY_LEN(ary); i+=2) {
                rb_yield(rb_assoc_new(RARRAY_AREF(ary, i), RARRAY_AREF(ary, i+1)));
            }
        }
        return ehash;
    }

each_key { |name| block } → Hash click to toggle source
each_key → Enumerator

Yields each environment variable name.

An `Enumerator` is returned if no block is given.

    static VALUE
    env_each_key(VALUE ehash)
    {
        VALUE keys;
        long i;

        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
        keys = env_keys();
        for (i=0; i<RARRAY_LEN(keys); i++) {
            rb_yield(RARRAY_AREF(keys, i));
        }
        return ehash;
    }

each_pair { |name, value| block } → Hash click to toggle source
each_pair → Enumerator

Yields each environment variable `name` and `value`.

If no block is given an `Enumerator` is returned.

    static VALUE
    env_each_pair(VALUE ehash)
    {
        char **env;
        VALUE ary;
        long i;

        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);

        ary = rb_ary_new();
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s) {
                rb_ary_push(ary, env_str_new(*env, s-*env));
                rb_ary_push(ary, env_str_new2(s+1));
            }
            env++;
        }
        FREE_ENVIRON(environ);

        if (rb_block_arity() > 1) {
            for (i=0; i<RARRAY_LEN(ary); i+=2) {
                rb_yield_values(2, RARRAY_AREF(ary, i), RARRAY_AREF(ary, i+1));
            }
        }
        else {
            for (i=0; i<RARRAY_LEN(ary); i+=2) {
                rb_yield(rb_assoc_new(RARRAY_AREF(ary, i), RARRAY_AREF(ary, i+1)));
            }
        }
        return ehash;
    }

each_value { |value| block } → Hash click to toggle source
each_value → Enumerator

Yields each environment variable `value`.

An `Enumerator` is returned if no block was given.

    static VALUE
    env_each_value(VALUE ehash)
    {
        VALUE values;
        long i;

        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
        values = env_values();
        for (i=0; i<RARRAY_LEN(values); i++) {
            rb_yield(RARRAY_AREF(values, i));
        }
        return ehash;
    }

empty? → true or false click to toggle source

Returns true when there are no environment variables

    static VALUE
    env_empty_p(void)
    {
        char **env;

        env = GET_ENVIRON(environ);
        if (env[0] == 0) {
            FREE_ENVIRON(environ);
            return Qtrue;
        }
        FREE_ENVIRON(environ);
        return Qfalse;
    }

fetch(name) → value click to toggle source
fetch(name, default) → value
fetch(name) { |missing_name| block } → value

Retrieves the environment variable `name`.

If the given name does not exist and neither `default` nor a block a provided an `KeyError` is raised. If a block is given it is called with the missing name to provide a value. If a default value is given it will be returned when no block is given.

    static VALUE
    env_fetch(int argc, VALUE *argv)
    {
        VALUE key;
        long block_given;
        const char *nam, *env;

        rb_check_arity(argc, 1, 2);
        key = argv[0];
        block_given = rb_block_given_p();
        if (block_given && argc == 2) {
            rb_warn("block supersedes default value argument");
        }
        nam = env_name(key);
        env = getenv(nam);
        if (!env) {
            if (block_given) return rb_yield(key);
            if (argc == 1) {
                rb_key_err_raise(rb_sprintf("key not found: \"%"PRIsVALUE"\"", key), envtbl, key);
            }
            return argv[1];
        }
        return env_name_new(nam, env);
    }

filter { |name, value| block } → Hash click to toggle source
filter → Enumerator

Returns a copy of the environment for entries where the block returns true.

Returns an `Enumerator` if no block was given.

`ENV.filter` is an alias for `ENV.select`.

    static VALUE
    env_select(VALUE ehash)
    {
        VALUE result;
        VALUE keys;
        long i;

        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
        result = rb_hash_new();
        keys = env_keys();
        for (i = 0; i < RARRAY_LEN(keys); ++i) {
            VALUE key = RARRAY_AREF(keys, i);
            VALUE val = rb_f_getenv(Qnil, key);
            if (!NIL_P(val)) {
                if (RTEST(rb_yield_values(2, key, val))) {
                    rb_hash_aset(result, key, val);
                }
            }
        }
        RB_GC_GUARD(keys);

        return result;
    }

filter! { |name, value| block } → ENV or nil click to toggle source
filter! → Enumerator

Equivalent to `ENV.keep_if` but returns `nil` if no changes were made.

`ENV.filter!` is an alias for `ENV.select!`.

    static VALUE
    env_select_bang(VALUE ehash)
    {
        VALUE keys;
        long i;
        int del = 0;

        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
        keys = env_keys();
        RBASIC_CLEAR_CLASS(keys);
        for (i=0; i<RARRAY_LEN(keys); i++) {
            VALUE val = rb_f_getenv(Qnil, RARRAY_AREF(keys, i));
            if (!NIL_P(val)) {
                if (!RTEST(rb_yield_values(2, RARRAY_AREF(keys, i), val))) {
                    FL_UNSET(RARRAY_AREF(keys, i), FL_TAINT);
                    env_delete(Qnil, RARRAY_AREF(keys, i));
                    del++;
                }
            }
        }
        RB_GC_GUARD(keys);
        if (del == 0) return Qnil;
        return envtbl;
    }

has_key?(name) → true or false click to toggle source

Returns `true` if there is an environment variable with the given `name`.

    static VALUE
    env_has_key(VALUE env, VALUE key)
    {
        const char *s;

        s = env_name(key);
        if (getenv(s)) return Qtrue;
        return Qfalse;
    }

has_value?(value) → true or false click to toggle source

Returns `true` if there is an environment variable with the given `value`.

    static VALUE
    env_has_value(VALUE dmy, VALUE obj)
    {
        char **env;

        obj = rb_check_string_type(obj);
        if (NIL_P(obj)) return Qnil;
        rb_check_safe_obj(obj);
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s++) {
                long len = strlen(s);
                if (RSTRING_LEN(obj) == len && strncmp(s, RSTRING_PTR(obj), len) == 0) {
                    FREE_ENVIRON(environ);
                    return Qtrue;
                }
            }
            env++;
        }
        FREE_ENVIRON(environ);
        return Qfalse;
    }

include?(name) → true or false click to toggle source

Returns `true` if there is an environment variable with the given `name`.

    static VALUE
    env_has_key(VALUE env, VALUE key)
    {
        const char *s;

        s = env_name(key);
        if (getenv(s)) return Qtrue;
        return Qfalse;
    }

index(value) → key click to toggle source

Deprecated method that is equivalent to `ENV.key`

    static VALUE
    env_index(VALUE dmy, VALUE value)
    {
        rb_warn("ENV.index is deprecated; use ENV.key");
        return env_key(dmy, value);
    }

inspect → string click to toggle source

Returns the contents of the environment as a `String`.

    static VALUE
    env_inspect(void)
    {
        char **env;
        VALUE str, i;

        str = rb_str_buf_new2("{");
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');

            if (env != environ) {
                rb_str_buf_cat2(str, ", ");
            }
            if (s) {
                rb_str_buf_cat2(str, "\"");
                rb_str_buf_cat(str, *env, s-*env);
                rb_str_buf_cat2(str, "\"=>");
                i = rb_inspect(rb_str_new2(s+1));
                rb_str_buf_append(str, i);
            }
            env++;
        }
        FREE_ENVIRON(environ);
        rb_str_buf_cat2(str, "}");
        OBJ_TAINT(str);

        return str;
    }

invert → Hash click to toggle source

Returns a new hash created by using environment variable names as values and values as names.

    static VALUE
    env_invert(void)
    {
        return rb_hash_invert(env_to_hash());
    }

keep_if { |name, value| block } → Hash click to toggle source
keep_if → Enumerator

Deletes every environment variable where the block evaluates to `false`.

Returns an enumerator if no block was given.

    static VALUE
    env_keep_if(VALUE ehash)
    {
        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
        env_select_bang(ehash);
        return envtbl;
    }

key(value) → name click to toggle source

Returns the name of the environment variable with `value`. If the value is not found `nil` is returned.

    static VALUE
    env_key(VALUE dmy, VALUE value)
    {
        char **env;
        VALUE str;

        SafeStringValue(value);
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s++) {
                long len = strlen(s);
                if (RSTRING_LEN(value) == len && strncmp(s, RSTRING_PTR(value), len) == 0) {
                    str = env_str_new(*env, s-*env-1);
                    FREE_ENVIRON(environ);
                    return str;
                }
            }
            env++;
        }
        FREE_ENVIRON(environ);
        return Qnil;
    }

key?(name) → true or false click to toggle source

Returns `true` if there is an environment variable with the given `name`.

    static VALUE
    env_has_key(VALUE env, VALUE key)
    {
        const char *s;

        s = env_name(key);
        if (getenv(s)) return Qtrue;
        return Qfalse;
    }

keys → Array click to toggle source

Returns every environment variable name in an `Array`

    static VALUE
    env_keys(void)
    {
        char **env;
        VALUE ary;

        ary = rb_ary_new();
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s) {
                rb_ary_push(ary, env_str_new(*env, s-*env));
            }
            env++;
        }
        FREE_ENVIRON(environ);
        return ary;
    }

length click to toggle source

Returns the number of environment variables.

    static VALUE
    env_size(void)
    {
        int i;
        char **env;

        env = GET_ENVIRON(environ);
        for (i=0; env[i]; i++)
            ;
        FREE_ENVIRON(environ);
        return INT2FIX(i);
    }

member?(name) → true or false click to toggle source

Returns `true` if there is an environment variable with the given `name`.

    static VALUE
    env_has_key(VALUE env, VALUE key)
    {
        const char *s;

        s = env_name(key);
        if (getenv(s)) return Qtrue;
        return Qfalse;
    }

rassoc(value) click to toggle source

Returns an `Array` of the name and value of the environment variable with `value` or `nil` if the value cannot be found.

    static VALUE
    env_rassoc(VALUE dmy, VALUE obj)
    {
        char **env;

        obj = rb_check_string_type(obj);
        if (NIL_P(obj)) return Qnil;
        rb_check_safe_obj(obj);
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s++) {
                long len = strlen(s);
                if (RSTRING_LEN(obj) == len && strncmp(s, RSTRING_PTR(obj), len) == 0) {
                    VALUE result = rb_assoc_new(rb_tainted_str_new(*env, s-*env-1), obj);
                    FREE_ENVIRON(environ);
                    return result;
                }
            }
            env++;
        }
        FREE_ENVIRON(environ);
        return Qnil;
    }

rehash click to toggle source

Re-hashing the environment variables does nothing. It is provided for compatibility with `Hash`.

    static VALUE
    env_none(void)
    {
        return Qnil;
    }

reject { |name, value| block } → Hash click to toggle source
reject → Enumerator

Same as `ENV.delete_if`, but works on (and returns) a copy of the environment.

    static VALUE
    env_reject(void)
    {
        return rb_hash_delete_if(env_to_hash());
    }

reject! { |name, value| block } → ENV or nil click to toggle source
reject! → Enumerator

Equivalent to `ENV.delete_if` but returns `nil` if no changes were made.

Returns an `Enumerator` if no block was given.

    static VALUE
    env_reject_bang(VALUE ehash)
    {
        VALUE keys;
        long i;
        int del = 0;

        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
        keys = env_keys();
        RBASIC_CLEAR_CLASS(keys);
        for (i=0; i<RARRAY_LEN(keys); i++) {
            VALUE val = rb_f_getenv(Qnil, RARRAY_AREF(keys, i));
            if (!NIL_P(val)) {
                if (RTEST(rb_yield_values(2, RARRAY_AREF(keys, i), val))) {
                    FL_UNSET(RARRAY_AREF(keys, i), FL_TAINT);
                    env_delete(Qnil, RARRAY_AREF(keys, i));
                    del++;
                }
            }
        }
        RB_GC_GUARD(keys);
        if (del == 0) return Qnil;
        return envtbl;
    }

replace(hash) → env click to toggle source

Replaces the contents of the environment variables with the contents of `hash`.

    static VALUE
    env_replace(VALUE env, VALUE hash)
    {
        VALUE keys;
        long i;

        keys = env_keys();
        if (env == hash) return env;
        hash = to_hash(hash);
        rb_hash_foreach(hash, env_replace_i, keys);

        for (i=0; i<RARRAY_LEN(keys); i++) {
            env_delete(env, RARRAY_AREF(keys, i));
        }
        RB_GC_GUARD(keys);
        return env;
    }

select { |name, value| block } → Hash click to toggle source
select → Enumerator

Returns a copy of the environment for entries where the block returns true.

Returns an `Enumerator` if no block was given.

`ENV.filter` is an alias for `ENV.select`.

    static VALUE
    env_select(VALUE ehash)
    {
        VALUE result;
        VALUE keys;
        long i;

        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
        result = rb_hash_new();
        keys = env_keys();
        for (i = 0; i < RARRAY_LEN(keys); ++i) {
            VALUE key = RARRAY_AREF(keys, i);
            VALUE val = rb_f_getenv(Qnil, key);
            if (!NIL_P(val)) {
                if (RTEST(rb_yield_values(2, key, val))) {
                    rb_hash_aset(result, key, val);
                }
            }
        }
        RB_GC_GUARD(keys);

        return result;
    }

select! { |name, value| block } → ENV or nil click to toggle source
select! → Enumerator

Equivalent to `ENV.keep_if` but returns `nil` if no changes were made.

`ENV.filter!` is an alias for `ENV.select!`.

    static VALUE
    env_select_bang(VALUE ehash)
    {
        VALUE keys;
        long i;
        int del = 0;

        RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size);
        keys = env_keys();
        RBASIC_CLEAR_CLASS(keys);
        for (i=0; i<RARRAY_LEN(keys); i++) {
            VALUE val = rb_f_getenv(Qnil, RARRAY_AREF(keys, i));
            if (!NIL_P(val)) {
                if (!RTEST(rb_yield_values(2, RARRAY_AREF(keys, i), val))) {
                    FL_UNSET(RARRAY_AREF(keys, i), FL_TAINT);
                    env_delete(Qnil, RARRAY_AREF(keys, i));
                    del++;
                }
            }
        }
        RB_GC_GUARD(keys);
        if (del == 0) return Qnil;
        return envtbl;
    }

shift → Array or nil click to toggle source

Removes an environment variable name-value pair from `ENV` and returns it as an `Array`. Returns `nil` if when the environment is empty.

    static VALUE
    env_shift(void)
    {
        char **env;
        VALUE result = Qnil;

        env = GET_ENVIRON(environ);
        if (*env) {
            char *s = strchr(*env, '=');
            if (s) {
                VALUE key = env_str_new(*env, s-*env);
                VALUE val = env_str_new2(getenv(RSTRING_PTR(key)));
                env_delete(Qnil, key);
                result = rb_assoc_new(key, val);
            }
        }
        FREE_ENVIRON(environ);
        return result;
    }

size click to toggle source

Returns the number of environment variables.

    static VALUE
    env_size(void)
    {
        int i;
        char **env;

        env = GET_ENVIRON(environ);
        for (i=0; env[i]; i++)
            ;
        FREE_ENVIRON(environ);
        return INT2FIX(i);
    }

slice(*keys) → a_hash click to toggle source

Returns a hash containing only the given keys from `ENV` and their values.

    ENV.slice("TERM","HOME")  #=> {"TERM"=>"xterm-256color", "HOME"=>"/Users/rhc"}

    static VALUE
    env_slice(int argc, VALUE *argv)
    {
        int i;
        VALUE key, value, result;

        if (argc == 0) {
            return rb_hash_new();
        }
        result = rb_hash_new_with_size(argc);

        for (i = 0; i < argc; i++) {
            key = argv[i];
            value = rb_f_getenv(Qnil, key);
            if (value != Qnil)
                rb_hash_aset(result, key, value);
        }

        return result;
    }

store(name, value) → value click to toggle source

Sets the environment variable `name` to `value`. If the value given is `nil` the environment variable is deleted. `name` must be a string.

    static VALUE
    env_aset(VALUE obj, VALUE nm, VALUE val)
    {
        char *name, *value;

        if (NIL_P(val)) {
            env_delete(obj, nm);
            return Qnil;
        }
        SafeStringValue(nm);
        SafeStringValue(val);
        /* nm can be modified in `val.to_str`, don't get `name` before
         * check for `val` */
        get_env_ptr(name, nm);
        get_env_ptr(value, val);

        ruby_setenv(name, value);
        if (ENVMATCH(name, PATH_ENV)) {
            RB_GC_GUARD(nm);
            if (OBJ_TAINTED(val)) {
                /* already tainted, no check */
                path_tainted = 1;
                return val;
            }
            else {
                path_tainted_p(value);
            }
        }
        else if (ENVMATCH(name, TZ_ENV)) {
            ruby_tz_uptodate_p = FALSE;
        }
        return val;
    }

to_a → Array click to toggle source

Converts the environment variables into an array of names and value arrays.

    ENV.to_a # => [["TERM", "xterm-color"], ["SHELL", "/bin/bash"], ...]

    static VALUE
    env_to_a(void)
    {
        char **env;
        VALUE ary;

        ary = rb_ary_new();
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s) {
                rb_ary_push(ary, rb_assoc_new(env_str_new(*env, s-*env),
                                              env_str_new2(s+1)));
            }
            env++;
        }
        FREE_ENVIRON(environ);
        return ary;
    }

to_h → hash click to toggle source
to_h {|name, value| block } → hash

Creates a hash with a copy of the environment variables.

    static VALUE
    env_to_h(void)
    {
        VALUE hash = env_to_hash();
        if (rb_block_given_p()) {
            hash = rb_hash_to_h_block(hash);
        }
        return hash;
    }

to_hash → hash click to toggle source

Creates a hash with a copy of the environment variables.

    static VALUE
    env_to_hash(void)
    {
        char **env;
        VALUE hash;

        hash = rb_hash_new();
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s) {
                rb_hash_aset(hash, env_str_new(*env, s-*env),
                                   env_str_new2(s+1));
            }
            env++;
        }
        FREE_ENVIRON(environ);
        return hash;
    }

to_s → "ENV" click to toggle source

Returns “ENV”

    static VALUE
    env_to_s(void)
    {
        return rb_usascii_str_new2("ENV");
    }

update(hash) → Hash click to toggle source
update(hash) { |name, old_value, new_value| block } → Hash

Adds the contents of `hash` to the environment variables. If no block is specified entries with duplicate keys are overwritten, otherwise the value of each duplicate name is determined by calling the block with the key, its value from the environment and its value from the hash.

    static VALUE
    env_update(VALUE env, VALUE hash)
    {
        if (env == hash) return env;
        hash = to_hash(hash);
        rb_hash_foreach(hash, env_update_i, 0);
        return env;
    }

value?(value) → true or false click to toggle source

Returns `true` if there is an environment variable with the given `value`.

    static VALUE
    env_has_value(VALUE dmy, VALUE obj)
    {
        char **env;

        obj = rb_check_string_type(obj);
        if (NIL_P(obj)) return Qnil;
        rb_check_safe_obj(obj);
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s++) {
                long len = strlen(s);
                if (RSTRING_LEN(obj) == len && strncmp(s, RSTRING_PTR(obj), len) == 0) {
                    FREE_ENVIRON(environ);
                    return Qtrue;
                }
            }
            env++;
        }
        FREE_ENVIRON(environ);
        return Qfalse;
    }

values → Array click to toggle source

Returns every environment variable value as an `Array`

    static VALUE
    env_values(void)
    {
        VALUE ary;
        char **env;

        ary = rb_ary_new();
        env = GET_ENVIRON(environ);
        while (*env) {
            char *s = strchr(*env, '=');
            if (s) {
                rb_ary_push(ary, env_str_new2(s+1));
            }
            env++;
        }
        FREE_ENVIRON(environ);
        return ary;
    }

values_at(name, ...) → Array click to toggle source

Returns an array containing the environment variable values associated with the given names. See also `ENV.select`.

    static VALUE
    env_values_at(int argc, VALUE *argv)
    {
        VALUE result;
        long i;

        result = rb_ary_new();
        for (i=0; i<argc; i++) {
            rb_ary_push(result, rb_f_getenv(Qnil, argv[i]));
        }
        return result;
    }