/usr/lib/ruby/vendor_ruby/sass/util/normalized_map.rb is in ruby-sass 3.4.6-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | require 'delegate'
require 'sass/util'
module Sass
module Util
# A hash that normalizes its string keys while still allowing you to get back
# to the original keys that were stored. If several different values normalize
# to the same value, whichever is stored last wins.
require 'sass/util/ordered_hash' if ruby1_8?
class NormalizedMap
# Create a normalized map
def initialize(map = nil)
@key_strings = {}
@map = Util.ruby1_8? ? OrderedHash.new : {}
map.each {|key, value| self[key] = value} if map
end
# Specifies how to transform the key.
#
# This can be overridden to create other normalization behaviors.
def normalize(key)
key.tr("-", "_")
end
# Returns the version of `key` as it was stored before
# normalization. If `key` isn't in the map, returns it as it was
# passed in.
#
# @return [String]
def denormalize(key)
@key_strings[normalize(key)] || key
end
# @private
def []=(k, v)
normalized = normalize(k)
@map[normalized] = v
@key_strings[normalized] = k
v
end
# @private
def [](k)
@map[normalize(k)]
end
# @private
def has_key?(k)
@map.has_key?(normalize(k))
end
# @private
def delete(k)
normalized = normalize(k)
@key_strings.delete(normalized)
@map.delete(normalized)
end
# @return [Hash] Hash with the keys as they were stored (before normalization).
def as_stored
Sass::Util.map_keys(@map) {|k| @key_strings[k]}
end
def empty?
@map.empty?
end
def values
@map.values
end
def keys
@map.keys
end
def each
@map.each {|k, v| yield(k, v)}
end
def size
@map.size
end
def to_hash
@map.dup
end
def to_a
@map.to_a
end
def map
@map.map {|k, v| yield(k, v)}
end
def dup
d = super
d.send(:instance_variable_set, "@map", @map.dup)
d
end
def sort_by
@map.sort_by {|k, v| yield k, v}
end
def update(map)
map = map.as_stored if map.is_a?(NormalizedMap)
map.each {|k, v| self[k] = v}
end
def method_missing(method, *args, &block)
if Sass.tests_running
raise ArgumentError.new("The method #{method} must be implemented explicitly")
end
@map.send(method, *args, &block)
end
if Sass::Util.ruby1_8?
def respond_to?(method, include_private = false)
super || @map.respond_to?(method, include_private)
end
end
def respond_to_missing?(method, include_private = false)
@map.respond_to?(method, include_private)
end
end
end
end
|