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.



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

def initialize(h = {}, opt = {})
  self.keys       = []
  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) 



532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
 
# File 'lib/deep/hash/struct/wrapper.rb', line 532

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)
    keys << name.to_sym unless keys.include?(name.to_sym)
  elsif block_given?
    __send__ "#{name}=", yield
    keys << name.to_sym unless keys.include?(name.to_sym)
  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.



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

def default
  @default
end

#keys ⇒ Object

Returns the value of attribute keys.



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

def keys
  @keys
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 



40
41
42
43
44
45
46
 
# File 'lib/deep/hash/struct/wrapper.rb', line 40

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

#===(klass) ⇒ Object 



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

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

#[](k) ⇒ Object 



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

def [](k)
  __send__ k
end

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



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

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

#blank? ⇒ Boolean

Returns:

  • (Boolean) 


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

def blank?
  keys.size.zero?
end

#clear ⇒ Object 



333
334
335
336
337
338
339
340
341
342
343
 
# File 'lib/deep/hash/struct/wrapper.rb', line 333

def clear
  unless default.nil?
    remove_instance_variable "@default"
    keys.delete :default
  end
  each_key do |k|
    remove_instance_variable "@#{k}"
  end
  self.keys = []
  self
end

#compact ⇒ Object 



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

def compact
  klass = dup

  klass.each do |k, v|
    klass.delete(k) if (v.class == self.class && v.blank?) || v.nil?
  end

  klass
end

#compact! ⇒ Object 



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

def compact!
  each do |k, v|
    delete(k) if (v.class == self.class && v.blank?) || v.nil?
  end

  self
end

#count ⇒ Object Also known as: size 



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

def count
  keys.size
end

#deep_compact ⇒ Object 



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

def deep_compact
  klass = deep_dup

  del_keys = klass.map do |k, v|
    flag  = if v.class == self.class
              klass[k] = v.deep_compact
              klass[k].present?
            else
              !v.nil?
            end
    next if flag
    k
  end.compact

  del_keys.each do |k|
    klass.delete k
  end

  klass
end

#deep_compact! ⇒ Object 



433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
 
# File 'lib/deep/hash/struct/wrapper.rb', line 433

def deep_compact!
  del_keys = map do |k, v|
    flag  = if v.class == self.class
              self[k] = v.deep_compact
              self[k].present?
            else
              !v.nil?
            end
    next if flag
    k
  end.compact

  del_keys.each do |k|
    delete k
  end

  self
end

#deep_dup(klass = self) ⇒ Object 



520
521
522
523
524
525
526
527
528
 
# File 'lib/deep/hash/struct/wrapper.rb', line 520

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 



129
130
131
132
133
134
135
136
137
 
# File 'lib/deep/hash/struct/wrapper.rb', line 129

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 



139
140
141
142
143
144
145
 
# File 'lib/deep/hash/struct/wrapper.rb', line 139

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 



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

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

#delete_if ⇒ Object Also known as: reject! 



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

def delete_if
  del_keys = map do |k, v|
    k if yield(k, v)
  end.compact
  del_keys.each do |k|
    delete k
  end
  self
end

#dig(*syms) ⇒ Object 



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

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

#dup ⇒ Object 



516
517
518
 
# File 'lib/deep/hash/struct/wrapper.rb', line 516

def dup
  self.class.new(to_h)
end

#each ⇒ Object 



52
53
54
55
56
57
58
59
60
 
# File 'lib/deep/hash/struct/wrapper.rb', line 52

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

#each_key ⇒ Object 



78
79
80
81
82
 
# File 'lib/deep/hash/struct/wrapper.rb', line 78

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

#each_value ⇒ Object 



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

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

#each_with_index ⇒ Object 



62
63
64
65
66
67
68
 
# File 'lib/deep/hash/struct/wrapper.rb', line 62

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

#each_with_object(init) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/deep/hash/struct/wrapper.rb', line 70

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

  init
end

#exclude?(k) ⇒ Boolean

Returns:

  • (Boolean) 


376
377
378
 
# File 'lib/deep/hash/struct/wrapper.rb', line 376

def exclude?(k)
  !include? k
end

#fetch(k, msg = nil) ⇒ Object 



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

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 



244
245
246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/deep/hash/struct/wrapper.rb', line 244

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 



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

def find
  klass = self.class.new

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

  klass
end

#flatten ⇒ Object 



358
359
360
 
# File 'lib/deep/hash/struct/wrapper.rb', line 358

def flatten
  to_h.flatten
end

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

Returns:

  • (Boolean) 


362
363
364
 
# File 'lib/deep/hash/struct/wrapper.rb', line 362

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

#has_keys?(*syms) ⇒ Boolean

Returns:

  • (Boolean) 


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

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 



322
323
324
325
326
327
328
329
330
 
# File 'lib/deep/hash/struct/wrapper.rb', line 322

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

#invert ⇒ Object 



266
267
268
269
270
 
# File 'lib/deep/hash/struct/wrapper.rb', line 266

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

#map ⇒ Object Also known as: collect 



209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/deep/hash/struct/wrapper.rb', line 209

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 



224
225
226
227
228
229
230
231
232
 
# File 'lib/deep/hash/struct/wrapper.rb', line 224

def map_key
  vs = []

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

  vs
end

#map_value ⇒ Object 



234
235
236
237
238
239
240
241
242
 
# File 'lib/deep/hash/struct/wrapper.rb', line 234

def map_value
  vs = []

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

  vs
end

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



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

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 



111
112
113
114
115
116
117
118
119
 
# File 'lib/deep/hash/struct/wrapper.rb', line 111

def merge(hash)
  klass = dup

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

  klass
end

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



121
122
123
124
125
126
 
# File 'lib/deep/hash/struct/wrapper.rb', line 121

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

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



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

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) 


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

def present?
  !blank?
end

#reject ⇒ Object 



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

def reject
  klass = self.class.new

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

  klass
end

#replace(other) ⇒ Object 



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

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 



165
166
167
168
169
170
171
172
173
174
 
# File 'lib/deep/hash/struct/wrapper.rb', line 165

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 



176
177
178
179
180
181
182
183
 
# File 'lib/deep/hash/struct/wrapper.rb', line 176

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 



147
148
149
150
151
152
153
154
155
 
# File 'lib/deep/hash/struct/wrapper.rb', line 147

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 



157
158
159
160
161
162
163
 
# File 'lib/deep/hash/struct/wrapper.rb', line 157

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 



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

def select
  klass = self.class.new

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

  klass
end

#shift ⇒ Object 



384
385
386
387
 
# File 'lib/deep/hash/struct/wrapper.rb', line 384

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

#slice(*syms) ⇒ Object 



452
453
454
455
456
457
458
459
460
 
# File 'lib/deep/hash/struct/wrapper.rb', line 452

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 



462
463
464
465
466
467
468
469
470
471
472
 
# File 'lib/deep/hash/struct/wrapper.rb', line 462

def slice!(*syms)
  del_keys = keys.map do |k|
    k unless syms.map(&:to_sym).include?(k)
  end.compact

  del_keys.each do |k|
    delete k
  end

  self
end

#sort ⇒ Object 



380
381
382
 
# File 'lib/deep/hash/struct/wrapper.rb', line 380

def sort
  to_h.sort
end

#to_a ⇒ Object Also known as: to_ary 



389
390
391
 
# File 'lib/deep/hash/struct/wrapper.rb', line 389

def to_a
  to_h.to_a
end

#to_hash ⇒ Object Also known as: to_h 



474
475
476
 
# File 'lib/deep/hash/struct/wrapper.rb', line 474

def to_hash
  deep_hash self
end

#to_json ⇒ Object 



479
480
481
 
# File 'lib/deep/hash/struct/wrapper.rb', line 479

def to_json
  to_h.to_json
end

#to_table(side_name = nil) ⇒ Object 



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

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 



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

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

#values_at(*syms) ⇒ Object 



259
260
261
262
263
264
 
# File 'lib/deep/hash/struct/wrapper.rb', line 259

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