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.5.2'
- 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
-
.args_for_arity(args, arity) ⇒ Object
-
.bcall(*args, &block) ⇒ Object
-
.blank?(value) ⇒ Boolean
-
.breadth_first_each(enumerable, accum = [], &block) ⇒ Object
-
.call(object, method, *args, &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
-
.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
-
.description ⇒ 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
-
.tap(*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(&block) ⇒ 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_params ⇒ 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.
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
# File 'lib/map.rb', line 204
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
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
|
# File 'lib/map.rb', line 641
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
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
|
# File 'lib/map.rb', line 894
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
919
920
921
922
923
924
925
926
|
# File 'lib/map.rb', line 919
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
# File 'lib/map.rb', line 98
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
33
34
35
36
37
38
|
# File 'lib/map.rb', line 33
def allocate
super.instance_eval do
@keys = []
self
end
end
|
.alphanumeric_key_for(key) ⇒ Object
1024
1025
1026
1027
1028
1029
1030
|
# File 'lib/map.rb', line 1024
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
|
.args_for_arity(args, arity) ⇒ Object
182
183
184
185
|
# File 'lib/map.rb', line 182
def args_for_arity(args, arity)
arity = Integer(arity.respond_to?(:arity) ? arity.arity : arity)
arity < 0 ? args.dup : args.slice(0, arity)
end
|
.bcall(*args, &block) ⇒ Object
192
193
194
195
|
# File 'lib/map.rb', line 192
def bcall(*args, &block)
args = Map.args_for_arity(args, block.arity)
block.call(*args)
end
|
.blank?(value) ⇒ Boolean
731
732
733
734
735
736
737
738
739
740
741
742
743
744
|
# File 'lib/map.rb', line 731
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
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
|
# File 'lib/map.rb', line 1097
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
|
.call(object, method, *args, &block) ⇒ Object
187
188
189
190
|
# File 'lib/map.rb', line 187
def call(object, method, *args, &block)
args = Map.args_for_arity(args, object.method(method).arity)
object.send(method, *args, &block)
end
|
.coerce(other) ⇒ Object
54
55
56
57
58
59
60
61
|
# File 'lib/map.rb', line 54
def coerce(other)
case other
when Map
other
else
allocate.update(other.to_hash)
end
end
|
.collection_has?(collection, key, &block) ⇒ Boolean
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
|
# File 'lib/map.rb', line 773
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
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
|
# File 'lib/map.rb', line 751
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
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
|
# File 'lib/map.rb', line 796
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
928
929
930
|
# File 'lib/map.rb', line 928
def Map.combine(*args)
Map.add(*args)
end
|
.conversion_methods ⇒ Object
69
70
71
72
73
74
75
76
77
78
79
80
81
|
# File 'lib/map.rb', line 69
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
257
258
259
|
# File 'lib/map.rb', line 257
def Map.convert_key(key)
key.kind_of?(Symbol) ? key.to_s : key
end
|
.convert_value(value) ⇒ Object
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
|
# File 'lib/map.rb', line 269
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
# File 'lib/map.rb', line 83
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
1166
1167
1168
|
# File 'lib/map.rb', line 1166
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
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
|
# File 'lib/map.rb', line 1046
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
1063
1064
1065
1066
1067
|
# File 'lib/map.rb', line 1063
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
1069
1070
1071
1072
1073
|
# File 'lib/map.rb', line 1069
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
|
.description ⇒ Object
11
12
13
|
# File 'lib/map.rb', line 11
def description
"the awesome ruby container you've always wanted: a string/symbol indifferent ordered hash that works in all rubies"
end
|
.each_pair(*args, &block) ⇒ Object
iterate over arguments in pairs smartly.
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
161
162
163
164
165
166
167
168
169
|
# File 'lib/map.rb', line 115
def each_pair(*args, &block)
size = args.size
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|
k, v = pair[0..1]
block.call(k, v)
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
1170
1171
1172
|
# File 'lib/map.rb', line 1170
def Map.evolve(object)
Map.for(object)
end
|
.explode(hash) ⇒ Object
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
|
# File 'lib/map.rb', line 876
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
47
48
49
50
51
52
|
# File 'lib/map.rb', line 47
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
541
542
543
544
545
|
# File 'lib/map.rb', line 541
def Map.from_hash(hash, order = nil)
map = Map.for(hash)
map.reorder!(order) if order
map
end
|
.intersection(a, b) ⇒ Object
172
173
174
175
176
|
# File 'lib/map.rb', line 172
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
1036
1037
1038
|
# File 'lib/map.rb', line 1036
def self.key_for(*keys)
return keys.flatten
end
|
.keys_for(enumerable) ⇒ Object
1122
1123
1124
1125
|
# File 'lib/map.rb', line 1122
def Map.keys_for(enumerable)
keys = enumerable.respond_to?(:keys) ? enumerable.keys : Array.new(enumerable.size){|i| i}
keys
end
|
.libdir(*args, &block) ⇒ Object
15
16
17
18
19
20
21
22
23
24
25
26
27
|
# File 'lib/map.rb', line 15
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
29
30
31
|
# File 'lib/map.rb', line 29
def load(*args, &block)
libdir{ Load.call(*args, &block) }
end
|
.map_for(hash) ⇒ Object
248
249
250
251
252
|
# File 'lib/map.rb', line 248
def Map.map_for(hash)
map = klass.coerce(hash)
map.default = hash.default
map
end
|
.match(haystack, needle) ⇒ Object
178
179
180
|
# File 'lib/map.rb', line 178
def match(haystack, needle)
intersection(haystack, needle) == needle
end
|
.new(*args, &block) ⇒ Object
Also known as:
[]
40
41
42
43
44
45
|
# File 'lib/map.rb', line 40
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
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
|
# File 'lib/map.rb', line 1075
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
|
.tap(*args, &block) ⇒ Object
63
64
65
66
67
|
# File 'lib/map.rb', line 63
def tap(*args, &block)
new(*args).tap do |map|
map.tap(&block) if block
end
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
515
516
517
518
519
|
# File 'lib/map.rb', line 515
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
501
502
503
504
505
506
507
508
509
510
511
512
513
|
# File 'lib/map.rb', line 501
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
521
522
523
|
# File 'lib/map.rb', line 521
def =~(hash)
to_hash == klass.coerce(hash).to_hash
end
|
#[](key) ⇒ Object
342
343
344
345
|
# File 'lib/map.rb', line 342
def [](key)
key = convert_key(key)
__get__(key)
end
|
#[]=(key, val) ⇒ Object
Also known as:
store
335
336
337
338
339
|
# File 'lib/map.rb', line 335
def []=(key, val)
key, val = convert(key, val)
keys.push(key) unless has_key?(key)
__set__(key, val)
end
|
#__get__ ⇒ Object
332
|
# File 'lib/map.rb', line 332
alias_method '__get__', '[]'
|
#__set__ ⇒ Object
331
|
# File 'lib/map.rb', line 331
alias_method '__set__', '[]='
|
#__update__ ⇒ Object
333
|
# File 'lib/map.rb', line 333
alias_method '__update__', 'update'
|
#add(*args) ⇒ Object
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
|
# File 'lib/map.rb', line 850
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 |bkey, btype|
set(bkey, btype.new) unless get(bkey).is_a?(btype)
end
exploded[:leaves].each do |lkey, lvalue|
set(lkey, lvalue)
end
self
end
|
#alphanumeric_key_for(key) ⇒ Object
#apply(other) ⇒ Object
1017
1018
1019
1020
1021
1022
|
# File 'lib/map.rb', line 1017
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
746
747
748
749
|
# File 'lib/map.rb', line 746
def blank?(*keys)
return empty? if keys.empty?
!has?(*keys) or Map.blank?(get(*keys))
end
|
#breadth_first_each(*args, &block) ⇒ Object
1139
1140
1141
|
# File 'lib/map.rb', line 1139
def breadth_first_each(*args, &block)
Map.breadth_first_each(self, *args, &block)
end
|
#clear ⇒ Object
430
431
432
433
|
# File 'lib/map.rb', line 430
def clear
keys.clear
super
end
|
#clone ⇒ Object
317
318
319
|
# File 'lib/map.rb', line 317
def clone
copy
end
|
#collection_has?(*args, &block) ⇒ Boolean
792
793
794
|
# File 'lib/map.rb', line 792
def collection_has?(*args, &block)
Map.collection_has?(*args, &block)
end
|
#collection_key(*args, &block) ⇒ Object
769
770
771
|
# File 'lib/map.rb', line 769
def collection_key(*args, &block)
Map.collection_key(*args, &block)
end
|
#collection_set(*args, &block) ⇒ Object
822
823
824
|
# File 'lib/map.rb', line 822
def collection_set(*args, &block)
Map.collection_set(*args, &block)
end
|
#combine(*args, &block) ⇒ Object
936
937
938
939
940
|
# File 'lib/map.rb', line 936
def combine(*args, &block)
dup.tap do |map|
map.combine!(*args, &block)
end
end
|
#combine!(*args, &block) ⇒ Object
932
933
934
|
# File 'lib/map.rb', line 932
def combine!(*args, &block)
add(*args, &block)
end
|
#contains(other) ⇒ Object
Also known as:
contains?
1143
1144
1145
1146
1147
|
# File 'lib/map.rb', line 1143
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
576
577
578
|
# File 'lib/map.rb', line 576
def conversion_methods
self.class.conversion_methods
end
|
#convert(key, val) ⇒ Object
297
298
299
|
# File 'lib/map.rb', line 297
def convert(key, val)
[convert_key(key), convert_value(val)]
end
|
#convert_key(key) ⇒ Object
261
262
263
264
265
266
267
|
# File 'lib/map.rb', line 261
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
288
289
290
291
292
293
294
|
# File 'lib/map.rb', line 288
def convert_value(value)
if klass.respond_to?(:convert_value)
klass.convert_value(value)
else
Map.convert_value(value)
end
end
|
#copy ⇒ Object
301
302
303
304
305
306
307
308
309
|
# File 'lib/map.rb', line 301
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
321
322
323
|
# File 'lib/map.rb', line 321
def default(key = nil)
key.is_a?(Symbol) && include?(key = key.to_s) ? self[key] : super
end
|
#default=(value) ⇒ Object
325
326
327
|
# File 'lib/map.rb', line 325
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
424
425
426
427
428
|
# File 'lib/map.rb', line 424
def delete(key)
key = convert_key(key)
keys.delete(key)
super(key)
end
|
#delete_if(&block) ⇒ Object
435
436
437
438
439
440
441
442
443
444
445
446
|
# File 'lib/map.rb', line 435
def delete_if(&block)
to_delete = []
each do |key, val|
args = [key, val]
to_delete.push(key) if !!Map.bcall(*args, &block)
end
to_delete.each{|key| delete(key)}
self
end
|
#depth_first_each(*args, &block) ⇒ Object
1127
1128
1129
|
# File 'lib/map.rb', line 1127
def depth_first_each(*args, &block)
Map.depth_first_each(self, *args, &block)
end
|
#depth_first_keys(*args, &block) ⇒ Object
1131
1132
1133
|
# File 'lib/map.rb', line 1131
def depth_first_keys(*args, &block)
Map.depth_first_keys(self, *args, &block)
end
|
#depth_first_values(*args, &block) ⇒ Object
1135
1136
1137
|
# File 'lib/map.rb', line 1135
def depth_first_values(*args, &block)
Map.depth_first_values(self, *args, &block)
end
|
#deserialize(object) ⇒ Object
1162
1163
1164
|
# File 'lib/map.rb', line 1162
def deserialize(object)
::Map.for(object)
end
|
#dup ⇒ Object
313
314
315
|
# File 'lib/map.rb', line 313
def dup
copy
end
|
#each ⇒ Object
Also known as:
each_pair
416
417
418
419
|
# File 'lib/map.rb', line 416
def each
keys.each{|key| yield(key, self[key])}
self
end
|
#each_key ⇒ Object
406
407
408
409
|
# File 'lib/map.rb', line 406
def each_key
keys.each{|key| yield(key)}
self
end
|
#each_value ⇒ Object
411
412
413
414
|
# File 'lib/map.rb', line 411
def each_value
keys.each{|key| yield self[key]}
self
end
|
#each_with_index ⇒ Object
401
402
403
404
|
# File 'lib/map.rb', line 401
def each_with_index
keys.each_with_index{|key, index| yield([key, self[key]], index)}
self
end
|
for rails’ extract_options! compat
1152
1153
1154
|
# File 'lib/map.rb', line 1152
def
true
end
|
#fetch(key, *args, &block) ⇒ Object
347
348
349
350
|
# File 'lib/map.rb', line 347
def fetch(key, *args, &block)
key = convert_key(key)
super(key, *args, &block)
end
|
#first ⇒ Object
391
392
393
|
# File 'lib/map.rb', line 391
def first
[keys.first, self[keys.first]]
end
|
#forcing(forcing = nil, &block) ⇒ Object
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
|
# File 'lib/map.rb', line 996
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
1012
1013
1014
1015
|
# File 'lib/map.rb', line 1012
def forcing?(forcing=nil)
@forcing ||= nil
@forcing == forcing
end
|
#get(*keys) ⇒ Object
support for compound key indexing and depth first iteration
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
|
# File 'lib/map.rb', line 674
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?
yield else
Map.collection_key(collection, key)
end
end
|
#has?(*keys) ⇒ Boolean
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
|
# File 'lib/map.rb', line 708
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
666
667
668
669
670
|
# File 'lib/map.rb', line 666
def id
return self[:id] if has_key?(:id)
return self[:_id] if has_key?(:_id)
raise NoMethodError
end
|
#initialize_from_array(array) ⇒ Object
237
238
239
240
|
# File 'lib/map.rb', line 237
def initialize_from_array(array)
map = self
Map.each_pair(array){|key, val| map[key] = val}
end
|
#initialize_from_hash(hash) ⇒ Object
231
232
233
234
235
|
# File 'lib/map.rb', line 231
def initialize_from_hash(hash)
map = self
map.update(hash)
map.default = hash.default
end
|
#inspect(*args, &block) ⇒ Object
569
570
571
572
|
# File 'lib/map.rb', line 569
def inspect(*args, &block)
require 'pp' unless defined?(PP)
PP.pp(self, '')
end
|
#invert ⇒ Object
547
548
549
550
551
552
|
# File 'lib/map.rb', line 547
def invert
inverted = klass.allocate
inverted.default = self.default
keys.each{|key| inverted[self[key]] = key }
inverted
end
|
#keep_if(&block) ⇒ Object
449
450
451
452
453
454
|
# File 'lib/map.rb', line 449
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?
352
353
354
|
# File 'lib/map.rb', line 352
def key?(key)
super(convert_key(key))
end
|
#key_for(*keys) ⇒ Object
1040
1041
1042
|
# File 'lib/map.rb', line 1040
def key_for(*keys)
self.class.key_for(*keys)
end
|
#keys ⇒ Object
200
201
202
|
# File 'lib/map.rb', line 200
def keys
@keys ||= []
end
|
#klass ⇒ Object
244
245
246
|
# File 'lib/map.rb', line 244
def klass
self.class
end
|
#last ⇒ Object
395
396
397
|
# File 'lib/map.rb', line 395
def last
[keys.last, self[keys.last]]
end
|
#leaf_for(key, options = {}, &block) ⇒ Object
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
|
# File 'lib/map.rb', line 942
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
253
254
255
|
# File 'lib/map.rb', line 253
def map_for(hash)
klass.map_for(hash)
end
|
#merge(*args) ⇒ Object
Also known as:
+
365
366
367
|
# File 'lib/map.rb', line 365
def merge(*args)
copy.update(*args)
end
|
#mongoize ⇒ Object
1174
1175
1176
|
# File 'lib/map.rb', line 1174
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
491
492
493
494
495
496
497
|
# File 'lib/map.rb', line 491
def pop
unless empty?
key = keys.last
val = delete(key)
[key, val]
end
end
|
#push(*args) ⇒ Object
481
482
483
484
485
486
487
488
489
|
# File 'lib/map.rb', line 481
def push(*args)
Map.each_pair(*args) do |key, val|
key = convert_key(key)
delete(key)
keys.push(key)
__set__(key, val)
end
self
end
|
#reject(&block) ⇒ Object
554
555
556
|
# File 'lib/map.rb', line 554
def reject(&block)
dup.delete_if(&block)
end
|
#reject!(&block) ⇒ Object
558
559
560
561
|
# File 'lib/map.rb', line 558
def reject!(&block)
hash = reject(&block)
self == hash ? nil : hash
end
|
#reorder(order = {}) ⇒ Object
527
528
529
530
531
532
533
|
# File 'lib/map.rb', line 527
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
535
536
537
|
# File 'lib/map.rb', line 535
def reorder!(order = {})
replace(reorder(order))
end
|
#replace(*args) ⇒ Object
456
457
458
459
|
# File 'lib/map.rb', line 456
def replace(*args)
clear
update(*args)
end
|
#respond_to?(method, *args, &block) ⇒ Boolean
660
661
662
663
664
|
# File 'lib/map.rb', line 660
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
370
371
372
373
374
|
# File 'lib/map.rb', line 370
def reverse_merge(hash)
map = copy
hash.each{|key, val| map[key] = val unless map.key?(key)}
map
end
|
#reverse_merge!(hash) ⇒ Object
376
377
378
|
# File 'lib/map.rb', line 376
def reverse_merge!(hash)
replace(reverse_merge(hash))
end
|
#rm(*args) ⇒ Object
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
|
# File 'lib/map.rb', line 969
def rm(*args)
paths, path = args.partition{|arg| arg.is_a?(Array)}
paths.push(path)
paths.each do |p|
if p.size == 1
delete(*p)
next
end
branch, leaf = p[0..-2], p[-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(#{ p.inspect })")
end
end
paths
end
|
#select ⇒ Object
563
564
565
566
567
|
# File 'lib/map.rb', line 563
def select
array = []
each{|key, val| array << [key,val] if yield(key, val)}
array
end
|
#serialize(object) ⇒ Object
for mongoid type system support
1158
1159
1160
|
# File 'lib/map.rb', line 1158
def serialize(object)
::Map.for(object)
end
|
#set(*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
|
# File 'lib/map.rb', line 826
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{|skey, svalue| [Array(skey), svalue]}
strategy.each do |skey, svalue|
leaf_for(skey, :autovivify => true) do |leaf, k|
Map.collection_set(leaf, k, svalue)
end
end
self
end
|
#shift ⇒ Object
ordered container specific methods
463
464
465
466
467
468
469
|
# File 'lib/map.rb', line 463
def shift
unless empty?
key = keys.first
val = delete(key)
[key, val]
end
end
|
#stringify_keys ⇒ Object
630
|
# File 'lib/map.rb', line 630
def stringify_keys; dup end
|
#stringify_keys! ⇒ Object
oh rails - would that map.rb existed before all this non-sense…
629
|
# File 'lib/map.rb', line 629
def stringify_keys!; self end
|
#struct ⇒ Object
45
46
47
|
# File 'lib/map/struct.rb', line 45
def struct
@struct ||= Struct.new(self)
end
|
#symbolize_keys ⇒ Object
632
|
# File 'lib/map.rb', line 632
def symbolize_keys; dup end
|
#symbolize_keys! ⇒ Object
631
|
# File 'lib/map.rb', line 631
def symbolize_keys!; self end
|
#to_array ⇒ Object
Also known as:
to_a
608
609
610
611
612
|
# File 'lib/map.rb', line 608
def to_array
array = []
each{|*pair| array.push(pair)}
array
end
|
#to_hash ⇒ Object
592
593
594
595
596
597
598
599
|
# File 'lib/map.rb', line 592
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
615
616
617
618
619
620
621
|
# File 'lib/map.rb', line 615
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
634
|
# File 'lib/map.rb', line 634
def to_options; dup end
|
#to_options! ⇒ Object
633
|
# File 'lib/map.rb', line 633
def to_options!; self end
|
#to_params ⇒ Object
33
34
35
36
37
38
39
40
41
|
# File 'lib/map/params.rb', line 33
def to_params
to_params = Array.new
depth_first_each do |key, val|
to_params.push(param_for(key))
end
to_params.join('&')
end
|
#to_s ⇒ Object
623
624
625
|
# File 'lib/map.rb', line 623
def to_s
to_array.to_s
end
|
#to_yaml(opts = {}) ⇒ Object
601
602
603
604
605
606
|
# File 'lib/map.rb', line 601
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
471
472
473
474
475
476
477
478
479
|
# File 'lib/map.rb', line 471
def unshift(*args)
Map.each_pair(*args) do |key, val|
key = convert_key(key)
delete(key)
keys.unshift(key)
__set__(key, val)
end
self
end
|
#update(*args) ⇒ Object
Also known as:
merge!
359
360
361
362
|
# File 'lib/map.rb', line 359
def update(*args)
Map.each_pair(*args){|key, val| store(key, val)}
self
end
|
#values ⇒ Object
Also known as:
vals
380
381
382
383
384
|
# File 'lib/map.rb', line 380
def values
array = []
keys.each{|key| array.push(self[key])}
array
end
|
#values_at(*keys) ⇒ Object
387
388
389
|
# File 'lib/map.rb', line 387
def values_at(*keys)
keys.map{|key| self[key]}
end
|
#with_indifferent_access ⇒ Object
636
|
# File 'lib/map.rb', line 636
def with_indifferent_access; dup end
|
#with_indifferent_access! ⇒ Object
635
|
# File 'lib/map.rb', line 635
def with_indifferent_access!; self end
|