Class: Map
- Inherits:
-
Hash
show all
- Defined in:
- lib/map.rb,
lib/map/params.rb,
lib/map/struct.rb,
lib/map/options.rb,
lib/map/integrations/active_record.rb
Defined Under Namespace
Modules: Arguments, Integrations, Options, Param
Classes: Struct
Constant Summary
collapse
- Version =
'6.4.0'
- Load =
Kernel.method(:load)
- Dup =
instance_method(:dup)
Class Method Summary
collapse
-
._explode(key, value, accum = {:branches => [], :leaves => []}) ⇒ Object
-
.add(*args) ⇒ Object
-
.add_conversion_method!(method) ⇒ Object
-
.allocate ⇒ Object
-
.alphanumeric_key_for(key) ⇒ Object
-
.blank?(value) ⇒ Boolean
-
.breadth_first_each(enumerable, accum = [], &block) ⇒ Object
-
.coerce(other) ⇒ Object
-
.collection_has?(collection, key, &block) ⇒ Boolean
-
.collection_key(collection, key, &block) ⇒ Object
-
.collection_set(collection, key, value, &block) ⇒ Object
-
.combine(*args) ⇒ Object
-
.conversion_methods ⇒ Object
-
.convert_key(key) ⇒ Object
def self.convert_key(key) key.kind_of?(Symbol) ? key.to_s : key end.
-
.convert_value(value) ⇒ Object
-
.define_conversion_method!(method) ⇒ Object
-
.demongoize(object) ⇒ Object
-
.depth_first_each(enumerable, path = [], accum = [], &block) ⇒ Object
TODO - technically this returns only leaves so the name isn’t quite right.
-
.depth_first_keys(enumerable, path = [], accum = [], &block) ⇒ Object
-
.depth_first_values(enumerable, path = [], accum = [], &block) ⇒ Object
-
.each_pair(*args, &block) ⇒ Object
iterate over arguments in pairs smartly.
-
.evolve(object) ⇒ Object
-
.explode(hash) ⇒ Object
-
.for(*args, &block) ⇒ Object
-
.from_hash(hash, order = nil) ⇒ Object
support for building ordered hasshes from a map’s own image.
-
.intersection(a, b) ⇒ Object
-
.key_for(*keys) ⇒ Object
-
.keys_for(enumerable) ⇒ Object
-
.libdir(*args, &block) ⇒ Object
-
.load(*args, &block) ⇒ Object
-
.map_for(hash) ⇒ Object
-
.match(haystack, needle) ⇒ Object
-
.new(*args, &block) ⇒ Object
(also: [])
-
.options_for(*args, &block) ⇒ Object
-
.options_for!(*args, &block) ⇒ Object
-
.pairs_for(enumerable, *args, &block) ⇒ Object
-
.struct(*args, &block) ⇒ Object
-
.update_options_for!(args, &block) ⇒ Object
-
.version ⇒ Object
Instance Method Summary
collapse
-
#<=>(other) ⇒ Object
-
#==(other) ⇒ Object
equality / sorting / matching support.
-
#=~(hash) ⇒ Object
-
#[](key) ⇒ Object
-
#[]=(key, val) ⇒ Object
(also: #store)
-
#__get__ ⇒ Object
-
#__set__ ⇒ Object
-
#__update__ ⇒ Object
-
#add(*args) ⇒ Object
-
#alphanumeric_key_for(key) ⇒ Object
-
#apply(other) ⇒ Object
-
#blank?(*keys) ⇒ Boolean
-
#breadth_first_each(*args, &block) ⇒ Object
-
#clear ⇒ Object
-
#clone ⇒ Object
-
#collection_has?(*args, &block) ⇒ Boolean
-
#collection_key(*args, &block) ⇒ Object
-
#collection_set(*args, &block) ⇒ Object
-
#combine(*args, &block) ⇒ Object
-
#combine!(*args, &block) ⇒ Object
-
#contains(other) ⇒ Object
(also: #contains?)
-
#conversion_methods ⇒ Object
-
#convert(key, val) ⇒ Object
-
#convert_key(key) ⇒ Object
-
#convert_value(value) ⇒ Object
(also: #convert_val)
-
#copy ⇒ Object
-
#default(key = nil) ⇒ Object
-
#default=(value) ⇒ Object
-
#delete(key) ⇒ Object
-
#delete_if ⇒ Object
-
#depth_first_each(*args, &block) ⇒ Object
-
#depth_first_keys(*args, &block) ⇒ Object
-
#depth_first_values(*args, &block) ⇒ Object
-
#deserialize(object) ⇒ Object
-
#dup ⇒ Object
-
#each ⇒ Object
(also: #each_pair)
-
#each_key ⇒ Object
-
#each_value ⇒ Object
-
#each_with_index ⇒ Object
-
#extractable_options? ⇒ Boolean
for rails’ extract_options! compat.
-
#fetch(key, *args, &block) ⇒ Object
-
#first ⇒ Object
-
#forcing(forcing = nil, &block) ⇒ Object
-
#forcing?(forcing = nil) ⇒ Boolean
-
#get(*keys) ⇒ Object
support for compound key indexing and depth first iteration.
-
#has?(*keys) ⇒ Boolean
-
#id ⇒ Object
-
#initialize(*args, &block) ⇒ Map
constructor
-
#initialize_from_array(array) ⇒ Object
-
#initialize_from_hash(hash) ⇒ Object
-
#inspect(*args, &block) ⇒ Object
-
#invert ⇒ Object
-
#keep_if(&block) ⇒ Object
-
#key?(key) ⇒ Boolean
(also: #include?, #has_key?, #member?)
-
#key_for(*keys) ⇒ Object
-
#keys ⇒ Object
-
#klass ⇒ Object
-
#last ⇒ Object
-
#leaf_for(key, options = {}, &block) ⇒ Object
-
#map_for(hash) ⇒ Object
-
#merge(*args) ⇒ Object
(also: #+)
-
#method_missing(*args, &block) ⇒ Object
a sane method missing that only supports writing values or reading *previously set* values.
-
#mongoize ⇒ Object
-
#name_for(*args, &block) ⇒ Object
-
#param_for(*args, &block) ⇒ Object
-
#pop ⇒ Object
-
#push(*args) ⇒ Object
-
#reject(&block) ⇒ Object
-
#reject!(&block) ⇒ Object
-
#reorder(order = {}) ⇒ Object
-
#reorder!(order = {}) ⇒ Object
-
#replace(*args) ⇒ Object
-
#respond_to?(method, *args, &block) ⇒ Boolean
-
#reverse_merge(hash) ⇒ Object
-
#reverse_merge!(hash) ⇒ Object
-
#rm(*args) ⇒ Object
-
#select ⇒ Object
-
#serialize(object) ⇒ Object
for mongoid type system support.
-
#set(*args) ⇒ Object
-
#shift ⇒ Object
ordered container specific methods.
-
#stringify_keys ⇒ Object
-
#stringify_keys! ⇒ Object
oh rails - would that map.rb existed before all this non-sense…
-
#struct ⇒ Object
-
#symbolize_keys ⇒ Object
-
#symbolize_keys! ⇒ Object
-
#to_array ⇒ Object
(also: #to_a)
-
#to_hash ⇒ Object
-
#to_list ⇒ Object
-
#to_options ⇒ Object
-
#to_options! ⇒ Object
-
#to_s ⇒ Object
-
#to_yaml(opts = {}) ⇒ Object
-
#unshift(*args) ⇒ Object
-
#update(*args) ⇒ Object
(also: #merge!)
-
#values ⇒ Object
(also: #vals)
-
#values_at(*keys) ⇒ Object
-
#with_indifferent_access ⇒ Object
-
#with_indifferent_access! ⇒ Object
Constructor Details
#initialize(*args, &block) ⇒ Map
Returns a new instance of Map.
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
# File 'lib/map.rb', line 180
def initialize(*args, &block)
case args.size
when 0
super(&block)
when 1
first = args.first
case first
when nil, false
nil
when Hash
initialize_from_hash(first)
when Array
initialize_from_array(first)
else
if first.respond_to?(:to_hash)
initialize_from_hash(first.to_hash)
else
initialize_from_hash(first)
end
end
else
initialize_from_array(args)
end
end
|
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(*args, &block) ⇒ Object
a sane method missing that only supports writing values or reading *previously set* values
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
|
# File 'lib/map.rb', line 617
def method_missing(*args, &block)
method = args.first.to_s
case method
when /=$/
key = args.shift.to_s.chomp('=')
value = args.shift
self[key] = value
when /\?$/
key = args.shift.to_s.chomp('?')
self.has?( key )
else
key = method
unless has_key?(key)
return(block ? fetch(key, &block) : super(*args))
end
self[key]
end
end
|
Class Method Details
._explode(key, value, accum = {:branches => [], :leaves => []}) ⇒ Object
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
|
# File 'lib/map.rb', line 870
def Map._explode(key, value, accum = {:branches => [], :leaves => []})
key = Array(key).flatten
case value
when Array
accum[:branches].push([key, Array])
value.each_with_index do |v, k|
Map._explode(key + [k], v, accum)
end
when Hash
accum[:branches].push([key, Map])
value.each do |k, v|
Map._explode(key + [k], v, accum)
end
else
accum[:leaves].push([key, value])
end
accum
end
|
.add(*args) ⇒ Object
895
896
897
898
899
900
901
902
|
# File 'lib/map.rb', line 895
def Map.add(*args)
args.flatten!
args.compact!
Map.for(args.shift).tap do |map|
args.each{|arg| map.add(arg)}
end
end
|
.add_conversion_method!(method) ⇒ Object
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
# File 'lib/map.rb', line 88
def add_conversion_method!(method)
if define_conversion_method!(method)
method = method.to_s.strip
raise ArguementError if method.empty?
module_eval(<<-__, __FILE__, __LINE__)
unless conversion_methods.include?(#{ method.inspect })
conversion_methods.unshift(#{ method.inspect })
end
__
true
else
false
end
end
|
.allocate ⇒ Object
29
30
31
32
33
34
|
# File 'lib/map.rb', line 29
def allocate
super.instance_eval do
@keys = []
self
end
end
|
.alphanumeric_key_for(key) ⇒ Object
1000
1001
1002
1003
1004
1005
1006
|
# File 'lib/map.rb', line 1000
def Map.alphanumeric_key_for(key)
return key if key.is_a?(Numeric)
digity, stringy, digits = %r/^(~)?(\d+)$/iomx.match(key).to_a
digity ? stringy ? String(digits) : Integer(digits) : key
end
|
.blank?(value) ⇒ Boolean
707
708
709
710
711
712
713
714
715
716
717
718
719
720
|
# File 'lib/map.rb', line 707
def Map.blank?(value)
return value.blank? if value.respond_to?(:blank?)
case value
when String
value.strip.empty?
when Numeric
value == 0
when false
true
else
value.respond_to?(:empty?) ? value.empty? : !value
end
end
|
.breadth_first_each(enumerable, accum = [], &block) ⇒ Object
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
|
# File 'lib/map.rb', line 1073
def Map.breadth_first_each(enumerable, accum = [], &block)
levels = []
keys = Map.depth_first_keys(enumerable)
keys.each do |key|
key.size.times do |i|
k = key.slice(0, i + 1)
level = k.size - 1
levels[level] ||= Array.new
last = levels[level].last
levels[level].push(k) unless last == k
end
end
levels.each do |level|
level.each do |key|
val = enumerable.get(key)
block ? block.call(key, val) : accum.push([key, val])
end
end
block ? enumerable : accum
end
|
.coerce(other) ⇒ Object
50
51
52
53
54
55
56
57
|
# File 'lib/map.rb', line 50
def coerce(other)
case other
when Map
other
else
allocate.update(other.to_hash)
end
end
|
.collection_has?(collection, key, &block) ⇒ Boolean
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
|
# File 'lib/map.rb', line 749
def Map.collection_has?(collection, key, &block)
has_key =
case collection
when Array
key = (Integer(key) rescue -1)
(0...collection.size).include?(key)
when Hash
collection.has_key?(key)
else
raise(IndexError, "(#{ collection.inspect })[#{ key.inspect }]")
end
block.call(key) if(has_key and block)
has_key
end
|
.collection_key(collection, key, &block) ⇒ Object
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
|
# File 'lib/map.rb', line 727
def Map.collection_key(collection, key, &block)
case collection
when Array
begin
key = Integer(key)
rescue
raise(IndexError, "(#{ collection.inspect })[#{ key.inspect }]")
end
collection[key]
when Hash
collection[key]
else
raise(IndexError, "(#{ collection.inspect })[#{ key.inspect }]")
end
end
|
.collection_set(collection, key, value, &block) ⇒ Object
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
|
# File 'lib/map.rb', line 772
def Map.collection_set(collection, key, value, &block)
set_key = false
case collection
when Array
begin
key = Integer(key)
rescue
raise(IndexError, "(#{ collection.inspect })[#{ key.inspect }]=#{ value.inspect }")
end
set_key = true
collection[key] = value
when Hash
set_key = true
collection[key] = value
else
raise(IndexError, "(#{ collection.inspect })[#{ key.inspect }]=#{ value.inspect }")
end
block.call(key) if(set_key and block)
[key, value]
end
|
.combine(*args) ⇒ Object
904
905
906
|
# File 'lib/map.rb', line 904
def Map.combine(*args)
Map.add(*args)
end
|
.conversion_methods ⇒ Object
59
60
61
62
63
64
65
66
67
68
69
70
71
|
# File 'lib/map.rb', line 59
def conversion_methods
@conversion_methods ||= (
map_like = ancestors.select{|ancestor| ancestor <= Map}
type_names = map_like.map do |ancestor|
name = ancestor.name.to_s.strip
next if name.empty?
name.downcase.gsub(/::/, '_')
end.compact
list = type_names.map{|type_name| "to_#{ type_name }"}
list.each{|method| define_conversion_method!(method)}
list
)
end
|
.convert_key(key) ⇒ Object
def self.convert_key(key)
key.kind_of?(Symbol) ? key.to_s : key
end
239
240
241
|
# File 'lib/map.rb', line 239
def self.convert_key(key)
key = key.kind_of?(Symbol) ? key.to_s : key
end
|
.convert_value(value) ⇒ Object
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
|
# File 'lib/map.rb', line 251
def self.convert_value(value)
conversion_methods.each do |method|
hashlike = value.is_a?(Hash)
if hashlike and value.respond_to?(method)
value = value.send(method)
break
end
end
case value
when Hash
coerce(value)
when Array
value.map!{|v| convert_value(v)}
else
value
end
end
|
.define_conversion_method!(method) ⇒ Object
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
# File 'lib/map.rb', line 73
def define_conversion_method!(method)
method = method.to_s.strip
raise ArguementError if method.empty?
module_eval(<<-__, __FILE__, __LINE__)
unless public_method_defined?(#{ method.inspect })
def #{ method }
self
end
true
else
false
end
__
end
|
.demongoize(object) ⇒ Object
1141
1142
1143
|
# File 'lib/map.rb', line 1141
def Map.demongoize(object)
Map.for(object)
end
|
.depth_first_each(enumerable, path = [], accum = [], &block) ⇒ Object
TODO - technically this returns only leaves so the name isn’t quite right. re-factor for 3.0
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
|
# File 'lib/map.rb', line 1022
def Map.depth_first_each(enumerable, path = [], accum = [], &block)
Map.pairs_for(enumerable) do |key, val|
path.push(key)
if((val.is_a?(Hash) or val.is_a?(Array)) and not val.empty?)
Map.depth_first_each(val, path, accum)
else
accum << [path.dup, val]
end
path.pop()
end
if block
accum.each{|keys, val| block.call(keys, val)}
else
accum
end
end
|
.depth_first_keys(enumerable, path = [], accum = [], &block) ⇒ Object
1039
1040
1041
1042
1043
|
# File 'lib/map.rb', line 1039
def Map.depth_first_keys(enumerable, path = [], accum = [], &block)
accum = Map.depth_first_each(enumerable, path = [], accum = [], &block)
accum.map!{|kv| kv.first}
accum
end
|
.depth_first_values(enumerable, path = [], accum = [], &block) ⇒ Object
1045
1046
1047
1048
1049
|
# File 'lib/map.rb', line 1045
def Map.depth_first_values(enumerable, path = [], accum = [], &block)
accum = Map.depth_first_each(enumerable, path = [], accum = [], &block)
accum.map!{|kv| kv.last}
accum
end
|
.each_pair(*args, &block) ⇒ Object
iterate over arguments in pairs smartly.
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
# File 'lib/map.rb', line 105
def each_pair(*args, &block)
size = args.size
parity = size % 2 == 0 ? :even : :odd
first = args.first
if block.nil?
result = []
block = lambda{|*kv| result.push(kv)}
else
result = args
end
return args if size == 0
if size == 1
conversion_methods.each do |method|
if first.respond_to?(method)
first = first.send(method)
break
end
end
if first.respond_to?(:each_pair)
first.each_pair do |key, val|
block.call(key, val)
end
return args
end
if first.respond_to?(:each_slice)
first.each_slice(2) do |key, val|
block.call(key, val)
end
return args
end
raise(ArgumentError, 'odd number of arguments for Map')
end
array_of_pairs = args.all?{|a| a.is_a?(Array) and a.size == 2}
if array_of_pairs
args.each do |pair|
key, val, *ignored = pair
block.call(key, val)
end
else
0.step(args.size - 1, 2) do |a|
key = args[a]
val = args[a + 1]
block.call(key, val)
end
end
args
end
|
.evolve(object) ⇒ Object
1145
1146
1147
|
# File 'lib/map.rb', line 1145
def Map.evolve(object)
Map.for(object)
end
|
.explode(hash) ⇒ Object
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
|
# File 'lib/map.rb', line 852
def Map.explode(hash)
accum = {:branches => [], :leaves => []}
hash.each do |key, value|
Map._explode(key, value, accum)
end
branches = accum[:branches]
leaves = accum[:leaves]
sort_by_key_size = proc{|a,b| a.first.size <=> b.first.size}
branches.sort!(&sort_by_key_size)
leaves.sort!(&sort_by_key_size)
accum
end
|
.for(*args, &block) ⇒ Object
43
44
45
46
47
48
|
# File 'lib/map.rb', line 43
def for(*args, &block)
if(args.size == 1 and block.nil?)
return args.first if args.first.class == self
end
new(*args, &block)
end
|
.from_hash(hash, order = nil) ⇒ Object
support for building ordered hasshes from a map’s own image
521
522
523
524
525
|
# File 'lib/map.rb', line 521
def Map.from_hash(hash, order = nil)
map = Map.for(hash)
map.reorder!(order) if order
map
end
|
.intersection(a, b) ⇒ Object
163
164
165
166
167
|
# File 'lib/map.rb', line 163
def intersection(a, b)
a, b, i = Map.for(a), Map.for(b), Map.new
a.depth_first_each{|key, val| i.set(key, val) if b.has?(key)}
i
end
|
.key_for(*keys) ⇒ Object
1012
1013
1014
|
# File 'lib/map.rb', line 1012
def self.key_for(*keys)
return keys.flatten
end
|
.keys_for(enumerable) ⇒ Object
1098
1099
1100
|
# File 'lib/map.rb', line 1098
def Map.keys_for(enumerable)
keys = enumerable.respond_to?(:keys) ? enumerable.keys : Array.new(enumerable.size){|i| i}
end
|
.libdir(*args, &block) ⇒ Object
11
12
13
14
15
16
17
18
19
20
21
22
23
|
# File 'lib/map.rb', line 11
def libdir(*args, &block)
@libdir ||= File.expand_path(__FILE__).sub(/\.rb$/,'')
libdir = args.empty? ? @libdir : File.join(@libdir, *args.map{|arg| arg.to_s})
ensure
if block
begin
$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.first==libdir
module_eval(&block)
ensure
$LOAD_PATH.shift() if $LOAD_PATH.first==libdir
end
end
end
|
.load(*args, &block) ⇒ Object
25
26
27
|
# File 'lib/map.rb', line 25
def load(*args, &block)
libdir{ Load.call(*args, &block) }
end
|
.map_for(hash) ⇒ Object
224
225
226
227
228
|
# File 'lib/map.rb', line 224
def Map.map_for(hash)
map = klass.coerce(hash)
map.default = hash.default
map
end
|
.match(haystack, needle) ⇒ Object
169
170
171
|
# File 'lib/map.rb', line 169
def match(haystack, needle)
intersection(haystack, needle) == needle
end
|
.new(*args, &block) ⇒ Object
Also known as:
[]
36
37
38
39
40
41
|
# File 'lib/map.rb', line 36
def new(*args, &block)
allocate.instance_eval do
initialize(*args, &block)
self
end
end
|
.options_for(*args, &block) ⇒ Object
160
161
162
|
# File 'lib/map/options.rb', line 160
def Map.options_for(*args, &block)
Map::Options.for(*args, &block)
end
|
.options_for!(*args, &block) ⇒ Object
164
165
166
|
# File 'lib/map/options.rb', line 164
def Map.options_for!(*args, &block)
Map::Options.for(*args, &block).pop
end
|
.pairs_for(enumerable, *args, &block) ⇒ Object
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
|
# File 'lib/map.rb', line 1051
def Map.pairs_for(enumerable, *args, &block)
if block.nil?
pairs, block = [], lambda{|*pair| pairs.push(pair)}
else
pairs = false
end
result =
case enumerable
when Hash
enumerable.each_pair(*args, &block)
when Array
enumerable.each_with_index(*args) do |val, key|
block.call(key, val)
end
else
enumerable.each_pair(*args, &block)
end
pairs ? pairs : result
end
|
.struct(*args, &block) ⇒ Object
49
50
51
|
# File 'lib/map/struct.rb', line 49
def Map.struct(*args, &block)
new(*args, &block).struct
end
|
.update_options_for!(args, &block) ⇒ Object
168
169
170
171
|
# File 'lib/map/options.rb', line 168
def Map.update_options_for!(args, &block)
options = Map.options_for(args)
block.call(options)
end
|
.version ⇒ Object
7
8
9
|
# File 'lib/map.rb', line 7
def version
Map::Version
end
|
Instance Method Details
#<=>(other) ⇒ Object
495
496
497
498
499
|
# File 'lib/map.rb', line 495
def <=>(other)
cmp = keys <=> klass.coerce(other).keys
return cmp unless cmp.zero?
values <=> klass.coerce(other).values
end
|
#==(other) ⇒ Object
equality / sorting / matching support
481
482
483
484
485
486
487
488
489
490
491
492
493
|
# File 'lib/map.rb', line 481
def ==(other)
case other
when Map
return false if keys != other.keys
super(other)
when Hash
self == Map.from_hash(other, self)
else
false
end
end
|
#=~(hash) ⇒ Object
501
502
503
|
# File 'lib/map.rb', line 501
def =~(hash)
to_hash == klass.coerce(hash).to_hash
end
|
#[](key) ⇒ Object
324
325
326
327
|
# File 'lib/map.rb', line 324
def [](key)
key = convert_key(key)
__get__(key)
end
|
#[]=(key, val) ⇒ Object
Also known as:
store
317
318
319
320
321
|
# File 'lib/map.rb', line 317
def []=(key, val)
key, val = convert(key, val)
keys.push(key) unless has_key?(key)
__set__(key, val)
end
|
#__get__ ⇒ Object
314
|
# File 'lib/map.rb', line 314
alias_method '__get__', '[]'
|
#__set__ ⇒ Object
313
|
# File 'lib/map.rb', line 313
alias_method '__set__', '[]='
|
#__update__ ⇒ Object
315
|
# File 'lib/map.rb', line 315
alias_method '__update__', 'update'
|
#add(*args) ⇒ Object
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
|
# File 'lib/map.rb', line 826
def add(*args)
case
when args.empty?
return []
when args.size == 1 && args.first.is_a?(Hash)
hash = args.shift
else
hash = {}
value = args.pop
key = Array(args).flatten
hash[key] = value
end
exploded = Map.explode(hash)
exploded[:branches].each do |key, type|
set(key, type.new) unless get(key).is_a?(type)
end
exploded[:leaves].each do |key, value|
set(key, value)
end
self
end
|
#alphanumeric_key_for(key) ⇒ Object
#apply(other) ⇒ Object
993
994
995
996
997
998
|
# File 'lib/map.rb', line 993
def apply(other)
Map.for(other).depth_first_each do |keys, value|
set(keys => value) unless !get(keys).nil?
end
self
end
|
#blank?(*keys) ⇒ Boolean
722
723
724
725
|
# File 'lib/map.rb', line 722
def blank?(*keys)
return empty? if keys.empty?
!has?(*keys) or Map.blank?(get(*keys))
end
|
#breadth_first_each(*args, &block) ⇒ Object
1114
1115
1116
|
# File 'lib/map.rb', line 1114
def breadth_first_each(*args, &block)
Map.breadth_first_each(enumerable=self, *args, &block)
end
|
#clear ⇒ Object
412
413
414
415
|
# File 'lib/map.rb', line 412
def clear
keys.clear
super
end
|
#clone ⇒ Object
299
300
301
|
# File 'lib/map.rb', line 299
def clone
copy
end
|
#collection_has?(*args, &block) ⇒ Boolean
768
769
770
|
# File 'lib/map.rb', line 768
def collection_has?(*args, &block)
Map.collection_has?(*args, &block)
end
|
#collection_key(*args, &block) ⇒ Object
745
746
747
|
# File 'lib/map.rb', line 745
def collection_key(*args, &block)
Map.collection_key(*args, &block)
end
|
#collection_set(*args, &block) ⇒ Object
798
799
800
|
# File 'lib/map.rb', line 798
def collection_set(*args, &block)
Map.collection_set(*args, &block)
end
|
#combine(*args, &block) ⇒ Object
912
913
914
915
916
|
# File 'lib/map.rb', line 912
def combine(*args, &block)
dup.tap do |map|
map.combine!(*args, &block)
end
end
|
#combine!(*args, &block) ⇒ Object
908
909
910
|
# File 'lib/map.rb', line 908
def combine!(*args, &block)
add(*args, &block)
end
|
#contains(other) ⇒ Object
Also known as:
contains?
1118
1119
1120
1121
1122
|
# File 'lib/map.rb', line 1118
def contains(other)
other = other.is_a?(Hash) ? Map.coerce(other) : other
breadth_first_each{|key, value| return true if value == other}
return false
end
|
#conversion_methods ⇒ Object
556
557
558
|
# File 'lib/map.rb', line 556
def conversion_methods
self.class.conversion_methods
end
|
#convert(key, val) ⇒ Object
279
280
281
|
# File 'lib/map.rb', line 279
def convert(key, val)
[convert_key(key), convert_value(val)]
end
|
#convert_key(key) ⇒ Object
243
244
245
246
247
248
249
|
# File 'lib/map.rb', line 243
def convert_key(key)
if klass.respond_to?(:convert_key)
klass.convert_key(key)
else
Map.convert_key(key)
end
end
|
#convert_value(value) ⇒ Object
Also known as:
convert_val
270
271
272
273
274
275
276
|
# File 'lib/map.rb', line 270
def convert_value(value)
if klass.respond_to?(:convert_value)
klass.convert_value(value)
else
Map.convert_value(value)
end
end
|
#copy ⇒ Object
283
284
285
286
287
288
289
290
291
|
# File 'lib/map.rb', line 283
def copy
default = self.default
self.default = nil
copy = Marshal.load(Marshal.dump(self)) rescue Dup.bind(self).call()
copy.default = default
copy
ensure
self.default = default
end
|
#default(key = nil) ⇒ Object
303
304
305
|
# File 'lib/map.rb', line 303
def default(key = nil)
key.is_a?(Symbol) && include?(key = key.to_s) ? self[key] : super
end
|
#default=(value) ⇒ Object
307
308
309
|
# File 'lib/map.rb', line 307
def default=(value)
raise ArgumentError.new("Map doesn't work so well with a non-nil default value!") unless value.nil?
end
|
#delete(key) ⇒ Object
406
407
408
409
410
|
# File 'lib/map.rb', line 406
def delete(key)
key = convert_key(key)
keys.delete(key)
super(key)
end
|
#delete_if ⇒ Object
417
418
419
420
421
422
|
# File 'lib/map.rb', line 417
def delete_if
to_delete = []
keys.each{|key| to_delete.push(key) if yield(key)}
to_delete.each{|key| delete(key)}
self
end
|
#depth_first_each(*args, &block) ⇒ Object
1102
1103
1104
|
# File 'lib/map.rb', line 1102
def depth_first_each(*args, &block)
Map.depth_first_each(enumerable=self, *args, &block)
end
|
#depth_first_keys(*args, &block) ⇒ Object
1106
1107
1108
|
# File 'lib/map.rb', line 1106
def depth_first_keys(*args, &block)
Map.depth_first_keys(enumerable=self, *args, &block)
end
|
#depth_first_values(*args, &block) ⇒ Object
1110
1111
1112
|
# File 'lib/map.rb', line 1110
def depth_first_values(*args, &block)
Map.depth_first_values(enumerable=self, *args, &block)
end
|
#deserialize(object) ⇒ Object
1137
1138
1139
|
# File 'lib/map.rb', line 1137
def deserialize(object)
::Map.for(object)
end
|
#dup ⇒ Object
295
296
297
|
# File 'lib/map.rb', line 295
def dup
copy
end
|
#each ⇒ Object
Also known as:
each_pair
398
399
400
401
|
# File 'lib/map.rb', line 398
def each
keys.each{|key| yield(key, self[key])}
self
end
|
#each_key ⇒ Object
388
389
390
391
|
# File 'lib/map.rb', line 388
def each_key
keys.each{|key| yield(key)}
self
end
|
#each_value ⇒ Object
393
394
395
396
|
# File 'lib/map.rb', line 393
def each_value
keys.each{|key| yield self[key]}
self
end
|
#each_with_index ⇒ Object
383
384
385
386
|
# File 'lib/map.rb', line 383
def each_with_index
keys.each_with_index{|key, index| yield([key, self[key]], index)}
self
end
|
for rails’ extract_options! compat
1127
1128
1129
|
# File 'lib/map.rb', line 1127
def
true
end
|
#fetch(key, *args, &block) ⇒ Object
329
330
331
332
|
# File 'lib/map.rb', line 329
def fetch(key, *args, &block)
key = convert_key(key)
super(key, *args, &block)
end
|
#first ⇒ Object
373
374
375
|
# File 'lib/map.rb', line 373
def first
[keys.first, self[keys.first]]
end
|
#forcing(forcing = nil, &block) ⇒ Object
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
|
# File 'lib/map.rb', line 972
def forcing(forcing=nil, &block)
@forcing ||= nil
if block
begin
previous = @forcing
@forcing = forcing
block.call()
ensure
@forcing = previous
end
else
@forcing
end
end
|
#forcing?(forcing = nil) ⇒ Boolean
988
989
990
991
|
# File 'lib/map.rb', line 988
def forcing?(forcing=nil)
@forcing ||= nil
@forcing == forcing
end
|
#get(*keys) ⇒ Object
support for compound key indexing and depth first iteration
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
|
# File 'lib/map.rb', line 650
def get(*keys)
keys = key_for(keys)
if keys.size <= 1
if !self.has_key?(keys.first) && block_given?
return yield
else
return self[keys.first]
end
end
keys, key = keys[0..-2], keys[-1]
collection = self
keys.each do |k|
if Map.collection_has?(collection, k)
collection = Map.collection_key(collection, k)
else
collection = nil
end
unless collection.respond_to?('[]')
leaf = collection
return leaf
end
end
if !Map.collection_has?(collection, key) && block_given?
default_value = yield
else
Map.collection_key(collection, key)
end
end
|
#has?(*keys) ⇒ Boolean
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
|
# File 'lib/map.rb', line 684
def has?(*keys)
keys = key_for(keys)
collection = self
return Map.collection_has?(collection, keys.first) if keys.size <= 1
keys, key = keys[0..-2], keys[-1]
keys.each do |k|
if Map.collection_has?(collection, k)
collection = Map.collection_key(collection, k)
else
collection = nil
end
return collection unless collection.respond_to?('[]')
end
return false unless(collection.is_a?(Hash) or collection.is_a?(Array))
Map.collection_has?(collection, key)
end
|
#id ⇒ Object
642
643
644
645
646
|
# File 'lib/map.rb', line 642
def id
return self[:id] if has_key?(:id)
return self[:_id] if has_key?(:_id)
raise NoMethodError
end
|
#initialize_from_array(array) ⇒ Object
213
214
215
216
|
# File 'lib/map.rb', line 213
def initialize_from_array(array)
map = self
Map.each_pair(array){|key, val| map[key] = val}
end
|
#initialize_from_hash(hash) ⇒ Object
207
208
209
210
211
|
# File 'lib/map.rb', line 207
def initialize_from_hash(hash)
map = self
map.update(hash)
map.default = hash.default
end
|
#inspect(*args, &block) ⇒ Object
549
550
551
552
|
# File 'lib/map.rb', line 549
def inspect(*args, &block)
require 'pp' unless defined?(PP)
PP.pp(self, '')
end
|
#invert ⇒ Object
527
528
529
530
531
532
|
# File 'lib/map.rb', line 527
def invert
inverted = klass.allocate
inverted.default = self.default
keys.each{|key| inverted[self[key]] = key }
inverted
end
|
#keep_if(&block) ⇒ Object
425
426
427
428
429
430
|
# File 'lib/map.rb', line 425
def keep_if( &block )
raise RuntimeError.new( "can't modify frozen #{ self.class.name }" ) if frozen?
return to_enum( :keep_if ) unless block_given?
each { | key , val | delete key unless yield( key , val ) }
self
end
|
#key?(key) ⇒ Boolean
Also known as:
include?, has_key?, member?
334
335
336
|
# File 'lib/map.rb', line 334
def key?(key)
super(convert_key(key))
end
|
#key_for(*keys) ⇒ Object
1016
1017
1018
|
# File 'lib/map.rb', line 1016
def key_for(*keys)
self.class.key_for(*keys)
end
|
#keys ⇒ Object
176
177
178
|
# File 'lib/map.rb', line 176
def keys
@keys ||= []
end
|
#klass ⇒ Object
220
221
222
|
# File 'lib/map.rb', line 220
def klass
self.class
end
|
#last ⇒ Object
377
378
379
|
# File 'lib/map.rb', line 377
def last
[keys.last, self[keys.last]]
end
|
#leaf_for(key, options = {}, &block) ⇒ Object
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
|
# File 'lib/map.rb', line 918
def leaf_for(key, options = {}, &block)
leaf = self
key = Array(key).flatten
k = key.first
key.each_cons(2) do |a, b|
exists = Map.collection_has?(leaf, a)
case b
when Numeric
if options[:autovivify]
Map.collection_set(leaf, a, Array.new) unless exists
end
when String, Symbol
if options[:autovivify]
Map.collection_set(leaf, a, Map.new) unless exists
end
end
leaf = Map.collection_key(leaf, a)
k = b
end
block ? block.call(leaf, k) : [leaf, k]
end
|
#map_for(hash) ⇒ Object
229
230
231
|
# File 'lib/map.rb', line 229
def map_for(hash)
klass.map_for(hash)
end
|
#merge(*args) ⇒ Object
Also known as:
+
347
348
349
|
# File 'lib/map.rb', line 347
def merge(*args)
copy.update(*args)
end
|
#mongoize ⇒ Object
1149
1150
1151
|
# File 'lib/map.rb', line 1149
def mongoize
self
end
|
#name_for(*args, &block) ⇒ Object
26
27
28
29
30
31
|
# File 'lib/map/params.rb', line 26
def name_for(*args, &block)
options = Map.options_for!(args)
options[:value] = nil
args.push(options)
param_for(*args, &block)
end
|
#param_for(*args, &block) ⇒ Object
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
# File 'lib/map/params.rb', line 2
def param_for(*args, &block)
options = Map.options_for!(args)
prefix = options[:prefix] || 'map'
src_key = args.flatten.map{|arg| Map.alphanumeric_key_for(arg)}
dst_key = src_key.map{|k| k.is_a?(Numeric) ? 0 : k}
src = self
dst = Map.new
value =
if options.has_key?(:value)
options[:value]
else
src.get(src_key).to_s
end
dst.set(dst_key, value)
Param.param_for(dst, prefix)
end
|
#pop ⇒ Object
471
472
473
474
475
476
477
|
# File 'lib/map.rb', line 471
def pop
unless empty?
key = keys.last
val = delete(key)
[key, val]
end
end
|
#push(*args) ⇒ Object
459
460
461
462
463
464
465
466
467
468
469
|
# File 'lib/map.rb', line 459
def push(*args)
Map.each_pair(*args) do |key, val|
if key?(key)
delete(key)
else
keys.push(key)
end
__set__(key, val)
end
self
end
|
#reject(&block) ⇒ Object
534
535
536
|
# File 'lib/map.rb', line 534
def reject(&block)
dup.delete_if(&block)
end
|
#reject!(&block) ⇒ Object
538
539
540
541
|
# File 'lib/map.rb', line 538
def reject!(&block)
hash = reject(&block)
self == hash ? nil : hash
end
|
#reorder(order = {}) ⇒ Object
507
508
509
510
511
512
513
|
# File 'lib/map.rb', line 507
def reorder(order = {})
order = Map.for(order)
map = Map.new
keys = order.depth_first_keys | depth_first_keys
keys.each{|key| map.set(key, get(key))}
map
end
|
#reorder!(order = {}) ⇒ Object
515
516
517
|
# File 'lib/map.rb', line 515
def reorder!(order = {})
replace(reorder(order))
end
|
#replace(*args) ⇒ Object
432
433
434
435
|
# File 'lib/map.rb', line 432
def replace(*args)
clear
update(*args)
end
|
#respond_to?(method, *args, &block) ⇒ Boolean
636
637
638
639
640
|
# File 'lib/map.rb', line 636
def respond_to?(method, *args, &block)
has_key = has_key?(method)
setter = method.to_s =~ /=\Z/o
!!((!has_key and setter) or has_key or super)
end
|
#reverse_merge(hash) ⇒ Object
352
353
354
355
356
|
# File 'lib/map.rb', line 352
def reverse_merge(hash)
map = copy
hash.each{|key, val| map[key] = val unless map.key?(key)}
map
end
|
#reverse_merge!(hash) ⇒ Object
358
359
360
|
# File 'lib/map.rb', line 358
def reverse_merge!(hash)
replace(reverse_merge(hash))
end
|
#rm(*args) ⇒ Object
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
|
# File 'lib/map.rb', line 945
def rm(*args)
paths, path = args.partition{|arg| arg.is_a?(Array)}
paths.push(path)
paths.each do |path|
if path.size == 1
delete(*path)
next
end
branch, leaf = path[0..-2], path[-1]
collection = get(branch)
case collection
when Hash
key = leaf
collection.delete(key)
when Array
index = leaf
collection.delete_at(index)
else
raise(IndexError, "(#{ collection.inspect }).rm(#{ path.inspect })")
end
end
paths
end
|
#select ⇒ Object
543
544
545
546
547
|
# File 'lib/map.rb', line 543
def select
array = []
each{|key, val| array << [key,val] if yield(key, val)}
array
end
|
#serialize(object) ⇒ Object
for mongoid type system support
1133
1134
1135
|
# File 'lib/map.rb', line 1133
def serialize(object)
::Map.for(object)
end
|
#set(*args) ⇒ Object
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
|
# File 'lib/map.rb', line 802
def set(*args)
case
when args.empty?
return []
when args.size == 1 && args.first.is_a?(Hash)
hash = args.shift
else
hash = {}
value = args.pop
key = Array(args).flatten
hash[key] = value
end
strategy = hash.map{|key, value| [Array(key), value]}
strategy.each do |key, value|
leaf_for(key, :autovivify => true) do |leaf, k|
Map.collection_set(leaf, k, value)
end
end
self
end
|
#shift ⇒ Object
ordered container specific methods
439
440
441
442
443
444
445
|
# File 'lib/map.rb', line 439
def shift
unless empty?
key = keys.first
val = delete(key)
[key, val]
end
end
|
#stringify_keys ⇒ Object
606
|
# File 'lib/map.rb', line 606
def stringify_keys; dup end
|
#stringify_keys! ⇒ Object
oh rails - would that map.rb existed before all this non-sense…
605
|
# File 'lib/map.rb', line 605
def stringify_keys!; self end
|
#struct ⇒ Object
45
46
47
|
# File 'lib/map/struct.rb', line 45
def struct
@struct ||= Struct.new(map=self)
end
|
#symbolize_keys ⇒ Object
608
|
# File 'lib/map.rb', line 608
def symbolize_keys; dup end
|
#symbolize_keys! ⇒ Object
607
|
# File 'lib/map.rb', line 607
def symbolize_keys!; self end
|
#to_array ⇒ Object
Also known as:
to_a
584
585
586
587
588
|
# File 'lib/map.rb', line 584
def to_array
array = []
each{|*pair| array.push(pair)}
array
end
|
#to_hash ⇒ Object
568
569
570
571
572
573
574
575
|
# File 'lib/map.rb', line 568
def to_hash
hash = Hash.new(default)
each do |key, val|
val = val.to_hash if val.respond_to?(:to_hash)
hash[key] = val
end
hash
end
|
#to_list ⇒ Object
591
592
593
594
595
596
597
|
# File 'lib/map.rb', line 591
def to_list
list = []
each_pair do |key, val|
list[key.to_i] = val if(key.is_a?(Numeric) or key.to_s =~ %r/^\d+$/)
end
list
end
|
#to_options ⇒ Object
610
|
# File 'lib/map.rb', line 610
def to_options; dup end
|
#to_options! ⇒ Object
609
|
# File 'lib/map.rb', line 609
def to_options!; self end
|
#to_s ⇒ Object
599
600
601
|
# File 'lib/map.rb', line 599
def to_s
to_array.to_s
end
|
#to_yaml(opts = {}) ⇒ Object
577
578
579
580
581
582
|
# File 'lib/map.rb', line 577
def to_yaml( opts = {} )
map = self
YAML.quick_emit(self.object_id, opts){|out|
out.map('!omap'){|m| map.each{|k,v| m.add(k, v)}}
}
end
|
#unshift(*args) ⇒ Object
447
448
449
450
451
452
453
454
455
456
457
|
# File 'lib/map.rb', line 447
def unshift(*args)
Map.each_pair(*args) do |key, val|
if key?(key)
delete(key)
else
keys.unshift(key)
end
__set__(key, val)
end
self
end
|
#update(*args) ⇒ Object
Also known as:
merge!
341
342
343
344
|
# File 'lib/map.rb', line 341
def update(*args)
Map.each_pair(*args){|key, val| store(key, val)}
self
end
|
#values ⇒ Object
Also known as:
vals
362
363
364
365
366
|
# File 'lib/map.rb', line 362
def values
array = []
keys.each{|key| array.push(self[key])}
array
end
|
#values_at(*keys) ⇒ Object
369
370
371
|
# File 'lib/map.rb', line 369
def values_at(*keys)
keys.map{|key| self[key]}
end
|
#with_indifferent_access ⇒ Object
612
|
# File 'lib/map.rb', line 612
def with_indifferent_access; dup end
|
#with_indifferent_access! ⇒ Object
611
|
# File 'lib/map.rb', line 611
def with_indifferent_access!; self end
|