ENV is a hash-like accessor for environment variables.
- #
- A
- C
- D
- E
- F
- H
- I
- K
- L
- M
- R
- S
- T
- U
- V
Retrieves the value
for environment variable name
as a String. Returns nil
if the named variable does not
exist.
Source: show
static VALUE rb_f_getenv(VALUE obj, VALUE name) { const char *nam, *env; nam = env_name(name); env = getenv(nam); if (env) { if (ENVMATCH(nam, PATH_ENV) && !env_path_tainted(env)) { return env_path_str_new(env); } return env_str_new2(env); } return Qnil; }
Sets the environment variable name
to value
. If
the value given is nil
the environment variable is deleted.
name
must be a string.
Source: show
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); } } return val; }
Returns an Array of the name and value of the environment variable with
name
or nil
if the name cannot be found.
Source: show
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, rb_tainted_str_new2(e)); return Qnil; }
Removes every environment variable.
Source: show
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; }
ENV.delete(name) { |name| } → value Link
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.
Source: show
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; }
ENV.delete_if → Enumerator Link
Deletes every environment variable for which the block evaluates to
true
.
If no block is given an enumerator is returned instead.
Source: show
static VALUE env_delete_if(VALUE ehash) { RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size); env_reject_bang(ehash); return envtbl; }
ENV.each → Enumerator
ENV.each_pair { |name, value| } → Hash
ENV.each_pair → Enumerator Link
Yields each environment variable name
and value
.
If no block is given an Enumerator is returned.
Source: show
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; }
ENV.each_key → Enumerator Link
Yields each environment variable name.
An Enumerator is returned if no block is given.
Source: show
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; }
ENV.each_pair → Enumerator Link
Yields each environment variable name
and value
.
If no block is given an Enumerator is returned.
Source: show
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; }
ENV.each_value → Enumerator Link
Yields each environment variable value
.
An Enumerator is returned if no block was given.
Source: show
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; }
Returns true when there are no environment variables
Source: show
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; }
ENV.fetch(name, default) → value
ENV.fetch(name) { |missing_name| ... } → value Link
Retrieves the environment variable name
.
If the given name does not exist and neither default
nor a
block a provided an IndexError 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.
Source: show
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_raise(rb_eKeyError, "key not found: \"%"PRIsVALUE"\"", key); } return argv[1]; } if (ENVMATCH(nam, PATH_ENV) && !env_path_tainted(env)) return env_path_str_new(env); return env_str_new2(env); }
Returns true
if there is an environment variable with the
given name
.
Source: show
static VALUE env_has_key(VALUE env, VALUE key) { const char *s; s = env_name(key); if (getenv(s)) return Qtrue; return Qfalse; }
Returns true
if there is an environment variable with the
given value
.
Source: show
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; }
Returns true
if there is an environment variable with the
given name
.
Source: show
static VALUE env_has_key(VALUE env, VALUE key) { const char *s; s = env_name(key); if (getenv(s)) return Qtrue; return Qfalse; }
Deprecated method that is equivalent to ::key
Source: show
static VALUE env_index(VALUE dmy, VALUE value) { rb_warn("ENV.index is deprecated; use ENV.key"); return env_key(dmy, value); }
Returns the contents of the environment as a String.
Source: show
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; }
Returns a new hash created by using environment variable names as values and values as names.
Source: show
static VALUE env_invert(void) { return rb_hash_invert(env_to_hash()); }
ENV.keep_if → Enumerator Link
Deletes every environment variable where the block evaluates to
false
.
Returns an enumerator if no block was given.
Source: show
static VALUE env_keep_if(VALUE ehash) { RETURN_SIZED_ENUMERATOR(ehash, 0, 0, rb_env_size); env_select_bang(ehash); return envtbl; }
Returns the name of the environment variable with value
. If
the value is not found nil
is returned.
Source: show
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; }
Returns true
if there is an environment variable with the
given name
.
Source: show
static VALUE env_has_key(VALUE env, VALUE key) { const char *s; s = env_name(key); if (getenv(s)) return Qtrue; return Qfalse; }
Returns every environment variable name in an Array
Source: show
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; }
Returns the number of environment variables.
Source: show
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); }
Returns true
if there is an environment variable with the
given name
.
Source: show
static VALUE env_has_key(VALUE env, VALUE key) { const char *s; s = env_name(key); if (getenv(s)) return Qtrue; return Qfalse; }
Returns an Array of the name and value of the environment variable with
value
or nil
if the value cannot be found.
Source: show
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; }
Re-hashing the environment variables does nothing. It is provided for compatibility with Hash.
Source: show
static VALUE env_none(void) { return Qnil; }
ENV.reject → Enumerator Link
Same as ENV#delete_if, but works on (and returns) a copy of the environment.
Source: show
static VALUE env_reject(void) { return rb_hash_delete_if(env_to_hash()); }
ENV.reject! → Enumerator Link
Equivalent to ENV#delete_if but returns nil
if no changes were
made.
Returns an Enumerator if no block was given.
Source: show
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; }
Replaces the contents of the environment variables with the contents of
hash
.
Source: show
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; }
ENV.select → Enumerator Link
Returns a copy of the environment for entries where the block returns true.
Returns an Enumerator if no block was given.
Source: show
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; }
ENV.select! → Enumerator Link
Equivalent to ENV#keep_if but returns nil
if no changes were
made.
Source: show
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; }
Removes an environment variable name-value pair from ENV and returns it as an Array. Returns
nil
if when the environment is empty.
Source: show
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; }
Returns the number of environment variables.
Source: show
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); }
Sets the environment variable name
to value
. If
the value given is nil
the environment variable is deleted.
name
must be a string.
Source: show
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); } } return val; }
Converts the environment variables into an array of names and value arrays.
ENV.to_a # => [["TERM", "xterm-color"], ["SHELL", "/bin/bash"], ...]
Source: show
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; }
ENV.to_h → hash Link
Creates a hash with a copy of the environment variables.
Source: show
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; }
Creates a hash with a copy of the environment variables.
Source: show
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; }
Returns “ENV”
Source: show
static VALUE env_to_s(void) { return rb_usascii_str_new2("ENV"); }
ENV.update(hash) { |name, old_value, new_value| } → Hash Link
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.
Source: show
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; }
Returns true
if there is an environment variable with the
given value
.
Source: show
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; }
Returns every environment variable value as an Array
Source: show
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; }
Returns an array containing the environment variable values associated with the given names. See also ::select.
Source: show
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; }