kernel/core/env.rb

   1 # depends on: class.rb
   2
   3 ##
   4 # Interface to process environment variables.
   5
   6 class EnvironmentVariables
   7
   8   include Enumerable
   9
  10   def [](key)
  11     env_get(StringValue(key))
  12   end
  13
  14   def []=(key, value)
  15     env_set(StringValue(key), value.nil? ? nil : StringValue(value))
  16   end
  17   alias_method :store, :[]=
  18
  19   def delete(key)
  20     env_set(StringValue(key), nil)
  21   end
  22
  23   def fetch(*params)
  24     if params.size < 1
  25       raise ArgumentError, "wrong number of arguments (0 for 1)"
  26     elsif params.size > 2
  27       raise ArgumentError, "wrong number of arguments (#{params.size} for 2)"
  28     end
  29     if block_given? and params.size == 2
  30       warn "block supersedes default value argument"
  31     end
  32     value = self[params[0]]
  33     return value if value
  34     return yield(params[0]) if block_given?
  35     raise IndexError, "key not found" if params.size == 1
  36     return params[1]
  37   end
  38
  39   def include?(key)
  40     !self[key].nil?
  41   end
  42   alias_method :has_key?, :include?
  43   alias_method :key?, :include?
  44   # More efficient than using the one from Enumerable
  45   alias_method :member?, :include?
  46
  47   def to_s
  48     "ENV"
  49   end
  50
  51   def inspect
  52     to_hash.inspect
  53   end
  54
  55   def each
  56     to_hash.each { |k, v| yield k, v }
  57     self
  58   end
  59   alias_method :each_pair, :each
  60
  61   def reject!
  62     rejected = false
  63     each do |k, v|
  64       if yield k, v
  65         delete k
  66         rejected = true
  67       end
  68     end
  69     rejected ? self : nil
  70   end
  71
  72   def reject(&block)
  73     to_hash.reject(&block)
  74   end
  75
  76   def clear
  77     reject! { true }
  78   end
  79
  80   def delete_if(&block)
  81     reject!(&block)
  82     self
  83   end
  84
  85   def each_key
  86     each { |k, v| yield k }
  87   end
  88
  89   def each_value
  90     each { |k, v| yield v }
  91   end
  92
  93   def has_value?(value)
  94     to_hash.has_value? value
  95   end
  96   alias_method :value?, :has_value?
  97
  98   def values_at(*params)
  99     to_hash.values_at(*params)
 100   end
 101
 102   def invert
 103     to_hash.invert
 104   end
 105
 106   def keys
 107     to_hash.keys
 108   end
 109
 110   def values
 111     to_hash.values
 112   end
 113
 114   def empty?
 115     to_hash.empty?
 116   end
 117
 118   def length
 119     to_hash.length
 120   end
 121   alias_method :size, :length
 122
 123   def rehash
 124     # No need to do anything, our keys are always strings
 125   end
 126
 127   def replace(other)
 128     clear
 129     other.each { |k, v| self[k] = v }
 130   end
 131
 132   def shift
 133     hash = to_hash
 134     return nil if hash.empty?
 135     result = hash.shift
 136     delete result.first
 137     result
 138   end
 139
 140   def to_a
 141     to_hash.to_a
 142   end
 143
 144   public :to_hash
 145
 146   def update(other, &block)
 147     if block_given?
 148       other.each { |k, v| self[k] = yield k, self[k], v }
 149     else
 150       other.each { |k, v| self[k] = v }
 151     end
 152   end
 153
 154   # Missing and deprecated: index, indexes, indices
 155 end