class SassC::Util::NormalizedMap

def [](k)

Other tags:
    Private: - 
def [](k)
  @map[normalize(k)]
end

def []=(k, v)

Other tags:
    Private: - 
def []=(k, v)
  normalized = normalize(k)
  @map[normalized] = v
  @key_strings[normalized] = k
  v
end

def as_stored

Returns:
  • (Hash) - Hash with the keys as they were stored (before normalization). 
def as_stored
  SassC::Util.map_keys(@map) {|k| @key_strings[k]}
end

def delete(k)

Other tags:
    Private: - 
def delete(k)
  normalized = normalize(k)
  @key_strings.delete(normalized)
  @map.delete(normalized)
end

def denormalize(key)

Returns:
  • (String) - 
def denormalize(key)
  @key_strings[normalize(key)] || key
end

def dup 

def dup
  d = super
  d.send(:instance_variable_set, "@map", @map.dup)
  d
end

def each 

def each
  @map.each {|k, v| yield(k, v)}
end

def empty? 

def empty?
  @map.empty?
end

def has_key?(k)

Other tags:
    Private: - 
def has_key?(k)
  @map.has_key?(normalize(k))
end

def initialize(map = nil)

Create a normalized map 
def initialize(map = nil)
  @key_strings = {}
  @map = {}
  map.each {|key, value| self[key] = value} if map
end

def keys 

def keys
  @map.keys
end

def map 

def map
  @map.map {|k, v| yield(k, v)}
end

def method_missing(method, *args, &block) 

def method_missing(method, *args, &block)
  @map.send(method, *args, &block)
end

def normalize(key)

This can be overridden to create other normalization behaviors.
Specifies how to transform the key. 
def normalize(key)
  key.tr("-", "_")
end

def respond_to_missing?(method, include_private = false) 

def respond_to_missing?(method, include_private = false)
  @map.respond_to?(method, include_private)
end

def size 

def size
  @map.size
end

def sort_by 

def sort_by
  @map.sort_by {|k, v| yield k, v}
end

def to_a 

def to_a
  @map.to_a
end

def to_hash 

def to_hash
  @map.dup
end

def update(map) 

def update(map)
  map = map.as_stored if map.is_a?(NormalizedMap)
  map.each {|k, v| self[k] = v}
end

def values 

def values
  @map.values
end