Class: Deep::Hash::Struct::Wrapper

Inherits:
Object
  • Object
show all
Includes:
PP::Wrapper
Defined in:
lib/deep/hash/struct/wrapper.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from PP::Wrapper

#inspect, #pretty_print, #pretty_print_cycle

Constructor Details

#initialize(h = {}, opt = {}) ⇒ Wrapper

Returns a new instance of Wrapper.



15
16
17
18
19
20
21
 
# File 'lib/deep/hash/struct/wrapper.rb', line 15

def initialize(h = {}, opt = {})
  self.chain      = opt[:chain].nil? ? false : opt[:chain]
  self.parent_ins = opt[:parent_ins]
  self.parent_key = opt[:parent_key]
  return if h.nil? || h.count.zero?
  wrap h, self
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, arg = nil) ⇒ Object (private) 



518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
 
# File 'lib/deep/hash/struct/wrapper.rb', line 518

def method_missing(method_name, arg = nil)
  name = method_name.to_s.delete("=")

  if method_name.to_s.end_with? "="
    setting_chain_instance!(self, name, arg)
  elsif block_given?
    __send__ "#{name}=", yield
  else
    val = instance_variable_get "@#{name}"
    return val unless val.nil?
    return self.class.new({}, chain: true, parent_ins: self, parent_key: method_name) if default.nil?
    default
  end
rescue => e
  e.backtrace.shift
  raise
end

Instance Attribute Details

#chain ⇒ Object Also known as: chain?

Returns the value of attribute chain.



7
8
9
 
# File 'lib/deep/hash/struct/wrapper.rb', line 7

def chain
  @chain
end

#default ⇒ Object (readonly)

Returns the value of attribute default.



11
12
13
 
# File 'lib/deep/hash/struct/wrapper.rb', line 11

def default
  @default
end

#parent_ins ⇒ Object

Returns the value of attribute parent_ins.



7
8
9
 
# File 'lib/deep/hash/struct/wrapper.rb', line 7

def parent_ins
  @parent_ins
end

#parent_key ⇒ Object

Returns the value of attribute parent_key.



7
8
9
 
# File 'lib/deep/hash/struct/wrapper.rb', line 7

def parent_key
  @parent_key
end

Instance Method Details

#==(hash) ⇒ Object 



44
45
46
47
48
49
50
 
# File 'lib/deep/hash/struct/wrapper.rb', line 44

def ==(hash)
  if hash.class == self.class
    to_h == hash.to_h
  else
    to_h == hash
  end
end

#===(klass) ⇒ Object 



52
53
54
 
# File 'lib/deep/hash/struct/wrapper.rb', line 52

def ===(klass)
  self.class == klass
end

#[](k) ⇒ Object 



35
36
37
 
# File 'lib/deep/hash/struct/wrapper.rb', line 35

def [](k)
  __send__ k
end

#[]=(k, v) ⇒ Object Also known as: add 



39
40
41
 
# File 'lib/deep/hash/struct/wrapper.rb', line 39

def []=(k, v)
  __send__ "#{k}=", v
end

#blank? ⇒ Boolean

Returns:

  • (Boolean) 


99
100
101
 
# File 'lib/deep/hash/struct/wrapper.rb', line 99

def blank?
  keys.size.zero?
end

#clear ⇒ Object 



339
340
341
342
343
344
345
 
# File 'lib/deep/hash/struct/wrapper.rb', line 339

def clear
  remove_instance_variable "@default" unless default.nil?
  each_key do |k|
    remove_instance_variable "@#{k}"
  end
  self
end

#compact ⇒ Object 



396
397
398
399
400
401
402
403
404
 
# File 'lib/deep/hash/struct/wrapper.rb', line 396

def compact
  klass = dup

  klass.each do |k, v|
    klass.remove_instance_variable("@#{k}") if (v.class == self.class && v.blank?) || v.nil?
  end

  klass
end

#compact! ⇒ Object 



406
407
408
409
410
411
412
 
# File 'lib/deep/hash/struct/wrapper.rb', line 406

def compact!
  each do |k, v|
    remove_instance_variable("@#{k}") if (v.class == self.class && v.blank?) || v.nil?
  end

  self
end

#count ⇒ Object Also known as: size 



94
95
96
 
# File 'lib/deep/hash/struct/wrapper.rb', line 94

def count
  keys.size
end

#deep_compact ⇒ Object 



414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
 
# File 'lib/deep/hash/struct/wrapper.rb', line 414

def deep_compact
  klass = deep_dup

  klass.each do |k, v|
    flag  = if v.class == self.class
              klass[k] = v.deep_compact
              klass[k].present?
            else
              !v.nil?
            end
    next if flag
    klass.remove_instance_variable("@#{k}")
  end

  klass
end

#deep_compact! ⇒ Object 



431
432
433
434
435
436
437
438
439
440
441
442
443
444
 
# File 'lib/deep/hash/struct/wrapper.rb', line 431

def deep_compact!
  each do |k, v|
    flag  = if v.class == self.class
              self[k] = v.deep_compact
              self[k].present?
            else
              !v.nil?
            end
    next if flag
    remove_instance_variable("@#{k}")
  end

  self
end

#deep_dup(klass = self) ⇒ Object 



506
507
508
509
510
511
512
513
514
 
# File 'lib/deep/hash/struct/wrapper.rb', line 506

def deep_dup(klass = self)
  new_klass = self.class.new

  klass.each do |k, v|
    new_klass[k] = hash?(v) ? v.deep_dup(v) : v
  end

  new_klass
end

#deep_merge(hash, klass = self) ⇒ Object 



133
134
135
136
137
138
139
140
141
 
# File 'lib/deep/hash/struct/wrapper.rb', line 133

def deep_merge(hash, klass = self)
  klass = klass.deep_dup

  hash.each do |k , v|
    klass[k] = hash?(v) ? klass.deep_merge(v, klass[k]) : v
  end

  klass
end

#deep_merge!(hash, klass = self) ⇒ Object 



143
144
145
146
147
148
149
 
# File 'lib/deep/hash/struct/wrapper.rb', line 143

def deep_merge!(hash, klass = self)
  hash.each do |k, v|
    klass[k] = hash?(v) ? deep_merge!(v, klass[k]) : v
  end

  klass
end

#delete(k) ⇒ Object 



276
277
278
 
# File 'lib/deep/hash/struct/wrapper.rb', line 276

def delete(k)
  remove_instance_variable "@#{k}"
end

#delete_if ⇒ Object 



280
281
282
283
284
285
 
# File 'lib/deep/hash/struct/wrapper.rb', line 280

def delete_if
  each do |k, v|
    remove_instance_variable "@#{k}" if yield(k, v)
  end
  self
end

#dig(*syms) ⇒ Object 



107
108
109
110
111
112
113
 
# File 'lib/deep/hash/struct/wrapper.rb', line 107

def dig(*syms)
  syms.inject(self) do |h, k|
    h[k]
  end
rescue
  nil
end

#each ⇒ Object 



56
57
58
59
60
61
62
63
64
 
# File 'lib/deep/hash/struct/wrapper.rb', line 56

def each
  if block_given?
    keys.each do |k|
      yield k, self[k]
    end
  else
    to_h.each
  end
end

#each_key ⇒ Object 



82
83
84
85
86
 
# File 'lib/deep/hash/struct/wrapper.rb', line 82

def each_key
  keys.each do |k|
    yield k
  end
end

#each_value ⇒ Object 



88
89
90
91
92
 
# File 'lib/deep/hash/struct/wrapper.rb', line 88

def each_value
  values.each do |v|
    yield v
  end
end

#each_with_index ⇒ Object 



66
67
68
69
70
71
72
 
# File 'lib/deep/hash/struct/wrapper.rb', line 66

def each_with_index
  index = 0
  keys.each do |k|
    yield [k, self[k]], index
    index += 1
  end
end

#each_with_object(init) ⇒ Object 



74
75
76
77
78
79
80
 
# File 'lib/deep/hash/struct/wrapper.rb', line 74

def each_with_object(init)
  each do |k, v|
    yield [k, v], init
  end

  init
end

#exclude?(k) ⇒ Boolean

Returns:

  • (Boolean) 


378
379
380
 
# File 'lib/deep/hash/struct/wrapper.rb', line 378

def exclude?(k)
  !include? k
end

#fetch(k, msg = nil) ⇒ Object 



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/deep/hash/struct/wrapper.rb', line 189

def fetch(k, msg = nil)
  v = self[k]
  if block_given?
    if v.class == self.class || v.nil?
      yield k
    else
      v
    end
  else
    case v
    when self.class
      if v.blank?
        msg
      else
        to_h
      end
    when nil
      msg
    else
      v
    end
  end
end

#fetch_values(*syms) ⇒ Object 



248
249
250
251
252
253
254
255
256
257
258
259
260
261
 
# File 'lib/deep/hash/struct/wrapper.rb', line 248

def fetch_values(*syms)
  syms.map do |sym|
    if block_given?
      if keys.include?(sym)
        self[sym]
      else
        yield sym
      end
    else
      raise KeyError, "key not found: :#{sym}" unless keys.include?(sym)
      self[sym]
    end
  end
end

#find ⇒ Object 



287
288
289
290
291
292
293
294
295
296
297
298
 
# File 'lib/deep/hash/struct/wrapper.rb', line 287

def find
  klass = self.class.new

  each do |k, v|
    if yield(k, v)
      klass[k] = v
      break
    end
  end

  klass
end

#flatten ⇒ Object 



360
361
362
 
# File 'lib/deep/hash/struct/wrapper.rb', line 360

def flatten
  to_h.flatten
end

#has_key?(k) ⇒ Boolean Also known as: include?

Returns:

  • (Boolean) 


364
365
366
 
# File 'lib/deep/hash/struct/wrapper.rb', line 364

def has_key?(k)
  keys.include? k
end

#has_keys?(*syms) ⇒ Boolean

Returns:

  • (Boolean) 


369
370
371
372
373
374
375
376
 
# File 'lib/deep/hash/struct/wrapper.rb', line 369

def has_keys?(*syms)
  syms.inject(self) do |klass, sym|
    val = klass[sym]
    return false if val.class == self.class && val.blank?
    klass[sym]
  end
  true
end

#inject(init = 0) ⇒ Object Also known as: reduce 



328
329
330
331
332
333
334
335
336
 
# File 'lib/deep/hash/struct/wrapper.rb', line 328

def inject(init = 0)
  value = init.dup
  each do |k, v|
    val = yield init.dup, [k, v]
    next if val.nil?
    value += val
  end
  value
end

#invert ⇒ Object 



270
271
272
273
274
 
# File 'lib/deep/hash/struct/wrapper.rb', line 270

def invert
  each_with_object({}) do |(k, v), h|
    h[v] = k
  end
end

#keys ⇒ Object 



23
24
25
26
27
 
# File 'lib/deep/hash/struct/wrapper.rb', line 23

def keys
  instance_variables.reject { |k| k =~ /default|parent_ins|parent_key|chain/ }.map do |k|
    k.to_s[1..-1].to_sym
  end
end

#map ⇒ Object Also known as: collect 



213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/deep/hash/struct/wrapper.rb', line 213

def map
  if block_given?
    vs = []

    each do |k, v|
      vs << yield(k, v)
    end

    vs
  else
    to_h.map
  end
end

#map_key ⇒ Object 



228
229
230
231
232
233
234
235
236
 
# File 'lib/deep/hash/struct/wrapper.rb', line 228

def map_key
  vs = []

  keys.each do |k|
    vs << yield(k)
  end

  vs
end

#map_value ⇒ Object 



238
239
240
241
242
243
244
245
246
 
# File 'lib/deep/hash/struct/wrapper.rb', line 238

def map_value
  vs = []

  values.each do |v|
    vs << yield(v)
  end

  vs
end

#max_stages(klass = self, i = 1) ⇒ Object 



473
474
475
476
477
478
479
480
481
482
 
# File 'lib/deep/hash/struct/wrapper.rb', line 473

def max_stages(klass = self, i = 1)
  klass.map_value do |v|
    case v
    when self.class
      max_stages v, i + 1
    else
      i
    end
  end.sort.last || 0
end

#merge(hash) ⇒ Object 



115
116
117
118
119
120
121
122
123
 
# File 'lib/deep/hash/struct/wrapper.rb', line 115

def merge(hash)
  klass = dup

  hash.each do |k, v|
    klass[k] = v
  end

  klass
end

#merge!(hash) ⇒ Object Also known as: update 



125
126
127
128
129
130
 
# File 'lib/deep/hash/struct/wrapper.rb', line 125

def merge!(hash)
  hash.each do |k, v|
    self[k] = v
  end
  self
end

#min_stages(klass = self, i = 1) ⇒ Object 



484
485
486
487
488
489
490
491
492
493
494
 
# File 'lib/deep/hash/struct/wrapper.rb', line 484

def min_stages(klass = self, i = 1)
  klass.map_value do |v|
    case v

    when self.class
      min_stages v, i + 1
    else
      i
    end
  end.delete_if(&:zero?).sort.first || 0
end

#present? ⇒ Boolean

Returns:

  • (Boolean) 


103
104
105
 
# File 'lib/deep/hash/struct/wrapper.rb', line 103

def present?
  !blank?
end

#reject ⇒ Object 



311
312
313
314
315
316
317
318
319
 
# File 'lib/deep/hash/struct/wrapper.rb', line 311

def reject
  klass = self.class.new

  each do |k, v|
    klass[k] = v unless yield(k, v)
  end

  klass
end

#reject! ⇒ Object 



321
322
323
324
325
326
 
# File 'lib/deep/hash/struct/wrapper.rb', line 321

def reject!
  each do |k, v|
    remove_instance_variable "@#{k}" if yield(k, v)
  end
  self
end

#replace(other) ⇒ Object 



347
348
349
350
351
352
353
354
355
356
357
358
 
# File 'lib/deep/hash/struct/wrapper.rb', line 347

def replace(other)
  h = if other.class == self.class
        other.to_hash
      elsif hash? other
        other
      else
        other.to_hash
      end

  clear
  wrap h, self
end

#reverse_deep_merge(hash, klass = self) ⇒ Object 



169
170
171
172
173
174
175
176
177
178
 
# File 'lib/deep/hash/struct/wrapper.rb', line 169

def reverse_deep_merge(hash, klass = self)
  klass = klass.deep_dup

  hash.each do |k , v|
    next if !hash?(v) && klass.include?(k)
    klass[k] = hash?(v) ? klass.reverse_deep_merge(v, klass[k]) : v
  end

  klass
end

#reverse_deep_merge!(hash) ⇒ Object 



180
181
182
183
184
185
186
187
 
# File 'lib/deep/hash/struct/wrapper.rb', line 180

def reverse_deep_merge!(hash)
  hash.each do |k, v|
    next if !hash?(v) && include?(k)
    self[k] = hash?(v) ? reverse_deep_merge(v, self[k]) : v
  end

  self
end

#reverse_merge(hash) ⇒ Object 



151
152
153
154
155
156
157
158
159
 
# File 'lib/deep/hash/struct/wrapper.rb', line 151

def reverse_merge(hash)
  klass = dup

  hash.each do |k, v|
    klass[k] = v if klass.exclude?(k)
  end

  klass
end

#reverse_merge!(hash) ⇒ Object 



161
162
163
164
165
166
167
 
# File 'lib/deep/hash/struct/wrapper.rb', line 161

def reverse_merge!(hash)
  hash.each do |k, v|
    self[k] = v if exclude?(k)
  end

  self
end

#select ⇒ Object Also known as: find_all 



300
301
302
303
304
305
306
307
308
 
# File 'lib/deep/hash/struct/wrapper.rb', line 300

def select
  klass = self.class.new

  each do |k, v|
    klass[k] = v if yield(k, v)
  end

  klass
end

#shift ⇒ Object 



386
387
388
389
 
# File 'lib/deep/hash/struct/wrapper.rb', line 386

def shift
  k = keys.first
  [k, remove_instance_variable("@#{k}")]
end

#slice(*syms) ⇒ Object 



446
447
448
449
450
451
452
453
454
 
# File 'lib/deep/hash/struct/wrapper.rb', line 446

def slice(*syms)
  klass = self.class.new

  each_key do |k|
    klass[k] = self[k] if syms.map(&:to_sym).include?(k)
  end

  klass
end

#slice!(*syms) ⇒ Object 



456
457
458
459
460
461
462
 
# File 'lib/deep/hash/struct/wrapper.rb', line 456

def slice!(*syms)
  each_key do |k|
    remove_instance_variable("@#{k}") unless syms.map(&:to_sym).include?(k)
  end

  self
end

#sort ⇒ Object 



382
383
384
 
# File 'lib/deep/hash/struct/wrapper.rb', line 382

def sort
  to_h.sort
end

#to_a ⇒ Object Also known as: to_ary 



391
392
393
 
# File 'lib/deep/hash/struct/wrapper.rb', line 391

def to_a
  to_h.to_a
end

#to_hash ⇒ Object Also known as: to_h 



464
465
466
 
# File 'lib/deep/hash/struct/wrapper.rb', line 464

def to_hash
  deep_hash self
end

#to_json ⇒ Object 



469
470
471
 
# File 'lib/deep/hash/struct/wrapper.rb', line 469

def to_json
  to_h.to_json
end

#to_table(side_name = nil) ⇒ Object 



496
497
498
499
500
501
502
503
504
 
# File 'lib/deep/hash/struct/wrapper.rb', line 496

def to_table(side_name = nil)
  if min_stages >= 2
    values.flat_map(&:keys).uniq.map do |side|
      map_value { |v| v[side] }.unshift side
    end.unshift keys.unshift(side_name)
  else
    deep_table to_h
  end
end

#values ⇒ Object 



29
30
31
32
33
 
# File 'lib/deep/hash/struct/wrapper.rb', line 29

def values
  keys.map do |k|
    self[k]
  end
end

#values_at(*syms) ⇒ Object 



263
264
265
266
267
268
 
# File 'lib/deep/hash/struct/wrapper.rb', line 263

def values_at(*syms)
  syms.map do |sym|
    v = self[sym]
    (v.nil? || (v.class == self.class && v.blank?)) ? nil : v
  end
end