ENV

class ENV

Parent:Object

ENV是一个类似于散列的环境变量访问器。

公共类方法

ENVname → value Show source

以String形式检索环境变量名称的值，如果指定的变量不存在，则返回零。

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

ENVname = value Show source

将环境变量名称设置为值，如果给定的值为零，则删除环境变量。名称必须是字符串。

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

assoc(name) → Array or nil Show source

如果找不到名称，则返回带名称或nil的环境变量的名称和值的数组。

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 Show source

删除每个环境变量。

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 Show source

delete(name) { |name| } → value

用名称删除环境变量并返回变量的值。如果给出了一个块，它将在命名环境不存在时被调用。

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| } → Hash Show source

delete_if → Enumerator

删除块评估为true的每个环境变量。

如果没有给出块，则返回枚举器。

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| } → Hash Show source

each → Enumerator

each_pair { |name, value| } → Hash

each_pair → Enumerator

产生每个环境变量名称和值。

如果没有给出块，则返回枚举器。

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| } → Hash Show source

each_key → Enumerator

产生每个环境变量名称。

如果没有给出块，则返回枚举器。

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| } → Hash Show source

each_pair → Enumerator

产生每个环境变量名称和值。

如果没有给出块，则返回枚举器。

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| } → Hash Show source

each_value → Enumerator

产生每个环境变量值。

如果没有给出块，则返回枚举器。

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 Show source

没有环境变量时返回true

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 Show source

fetch(name, default) → value

fetch(name) { |missing_name| ... } → value

检索环境变量名称。

如果给定的名称不存在，并且不会引发提供IndexError的默认或块a。如果给出了一个块，则会使用缺少的名称调用该块来提供一个值。如果给出默认值，则在没有给出块时将返回它。

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];
    }
    return env_name_new(nam, env
}

has_key?(name) → true or false Show source

如果存在具有给定名称的环境变量，则返回true。

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 Show source

如果存在具有给定值的环境变量，则返回true。

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 Show source

如果存在具有给定名称的环境变量，则返回true。

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 Show source

不推荐的方法等价于:: 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 Show source

以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 Show source

通过使用环境变量名称作为值和值作为名称返回一个新的散列。

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

keep_if { |name, value| } → Hash Show source

keep_if → Enumerator

删除块评估为false的每个环境变量。

如果没有给出块，则返回一个枚举器。

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 Show source

返回值为环境变量的名称。如果未找到该值，则返回零。

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 Show source

如果存在具有给定名称的环境变量，则返回true。

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 Show source

返回数组中的每个环境变量名称

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 Show source

返回环境变量的数量。

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 Show source

如果存在具有给定名称的环境变量，则返回true。

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) Show source

如果找不到该值，则返回具有值或零的环境变量的名称和值的数组。

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 Show source

重新哈希环境变量不会有什么影响，它提供与Hash兼容。

static VALUE
env_none(void)
{
    return Qnil;
}

reject { |name, value| } → Hash Show source

reject → Enumerator

与ENV＃delete_if相同，但是可以处理（并返回）该环境的副本。

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

reject! { |name, value| } → ENV or nil Show source

reject! → Enumerator

相当于ENV＃delete_if，但如果没有更改，则返回nil。

如果没有给出块，则返回枚举器。

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 Show source

用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| } → Hash Show source

select → Enumerator

返回块返回true的条目的环境副本。

如果没有给出块，则返回枚举器。

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| } → ENV or nil Show source

select! → Enumerator

相当于ENV＃keep_if，如果没有更改，则返回nil。

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 Show source

从ENV中删除一个环境变量名称 - 值对，并将其作为数组返回。如果环境为空，则返回nil。

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 Show source

返回环境变量的数量。

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
}

store(name, value) → value Show source

将环境变量名称设置为值。如果给定的值为零，则删除环境变量。名称必须是字符串。

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

to_a → Array Show source

将环境变量转换为名称和值数组的数组。

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_hash → hash Show source

to_h → hash

使用环境变量的副本创建散列。

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_hash → hash Show source

使用环境变量的副本创建散列。

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" Show source

返回“ENV”

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

update(hash) → Hash Show source

update(hash) { |name, old_value, new_value| } → 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 Show source

如果存在具有给定值的环境变量，则返回true。

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 Show source

以数组形式返回每个环境变量值

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 Show source

返回包含与给定名称关联的环境变量值的数组。另见:: ::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;
}