Class: Hash

Inherits:
Object show all
Defined in:
lib/hash-utils/hash.rb

Overview

Hash extension.

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.combine(keys, values) ⇒ Object 



571
572
573
574
575
576
577
578
 
# File 'lib/hash-utils/hash.rb', line 571

def self.combine(keys, values)
    result = { }
    keys.each_index do |i|
        result[keys[i]] = values[i]
    end
    
    return result
end

.create(default = nil, hash = { }, &block) ⇒ Object 



42
43
44
45
46
 
# File 'lib/hash-utils/hash.rb', line 42

def self.create(default = nil, hash = { }, &block)
    hash.default = default
    hash.default_proc = block if not block.nil?
    return hash        
end

.define(values = { }, default = nil, &block) ⇒ Object 



25
26
27
28
 
# File 'lib/hash-utils/hash.rb', line 25

def self.define(values = { }, default = nil, &block) 
    hash = self[values]
    self::create(default, hash, &block)
end

Instance Method Details

#all_pairs?(&block) ⇒ Boolean

Returns:

  • (Boolean) 


336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/hash-utils/hash.rb', line 336

def all_pairs?(&block)
    return true if self.empty?
    
    self.each_pair do |k, v|
        if block.call(k, v) == false
            return false
        end
    end
    
    return true
end

#asort(&block) ⇒ Object 



458
459
460
461
462
463
 
# File 'lib/hash-utils/hash.rb', line 458

def asort(&block)
    if block.nil?
       block =  Proc::new { |a, b| a <=> b }
    end
    Hash[self.sort { |a, b| block.call(a[1], b[1]) }]
end

#asort!(&block) ⇒ Object 



476
477
478
 
# File 'lib/hash-utils/hash.rb', line 476

def asort!(&block)
    self.replace(self.asort(&block))
end

#avg ⇒ Object Also known as: average 



807
808
809
 
# File 'lib/hash-utils/hash.rb', line 807

def avg
    self.values.avg
end

#clean(value = nil) ⇒ Object Also known as: compact

Removes given value from the hash. It’s nil by default, so behaves just as #compact.

Parameters:

  • value (Object) (defaults to: nil) —

    required value; uses === for comparing

Since:

  • 0.19.0



115
116
117
 
# File 'lib/hash-utils/hash.rb', line 115

def clean(value = nil)
    self.reject { |k, v| v === value }
end

#clean!(value = nil) ⇒ Object Also known as: compact!

Removes given value from the hash in place. It’s nil by default, so behaves just as #compact.

Parameters:

  • value (Object) (defaults to: nil) —

    required value; uses === for comparing

Since:

  • 0.19.0



128
129
130
 
# File 'lib/hash-utils/hash.rb', line 128

def clean!(value = nil)
    self.reject! { |k, v| v === value }
end

#deep_merge(*args) ⇒ Object 



620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
 
# File 'lib/hash-utils/hash.rb', line 620

def deep_merge(*args)
    result = self.dup
    fm = args.map { |hash| [result, hash] }
    
    while not fm.empty?
        _in, _out = fm.shift
        _out.each_pair do |k, v|
            if _in[k].kind_of? Hash
                _in[k] = _in[k].dup
                fm << [_in[k], _out[k]]
            else
                _in[k] = v
            end
        end
    end
    
    return result
end

#deep_merge!(*args) ⇒ Object 



591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
 
# File 'lib/hash-utils/hash.rb', line 591

def deep_merge!(*args)
    fm = args.map { |hash| [self, hash] }
    
    while not fm.empty?
        _in, _out = fm.shift
        _out.each_pair do |k, v|
            if v.kind_of? Hash
                fm << [_in[k], _out[k]]
            else
                _in[k] = v
            end
        end
    end
    
    return self
end

#flip ⇒ Object 



836
837
838
 
# File 'lib/hash-utils/hash.rb', line 836

def flip
    self.map_pairs { |k, v| [v, k] }
end

#flip! ⇒ Object 



849
850
851
 
# File 'lib/hash-utils/hash.rb', line 849

def flip!
    self.map_pairs! { |k, v| [v, k] }
end

#get_items(*args) ⇒ Object 



674
675
676
677
678
679
680
681
 
# File 'lib/hash-utils/hash.rb', line 674

def get_items(*args)
    result = { }
    self.get_pairs(*args) do |key, value|
        result[key] = value
    end
    
    return result
end

#get_pairs(*args) ⇒ Object 



650
651
652
653
654
655
656
 
# File 'lib/hash-utils/hash.rb', line 650

def get_pairs(*args)
    self.take_pairs(*args) do |i|
        if not i[1].nil?
            yield i
        end
    end
end

#get_values(*args) ⇒ Object 



697
698
699
700
701
702
703
704
 
# File 'lib/hash-utils/hash.rb', line 697

def get_values(*args)
    result = [ ]
    self.get_pairs(*args) do |key, value|
        result << value
    end
    
    return result
end

#has_all?(keys) ⇒ Boolean Also known as: has_keys?

Returns:

  • (Boolean) 


519
520
521
522
523
524
525
526
527
 
# File 'lib/hash-utils/hash.rb', line 519

def has_all?(keys)
    keys.each do |key|
        if not self.has_key? key
            return false
        end
    end
    
    return true
end

#has_some?(keys) ⇒ Boolean

Returns:

  • (Boolean) 


543
544
545
546
547
548
549
550
551
 
# File 'lib/hash-utils/hash.rb', line 543

def has_some?(keys)
    keys.each do |key|
        if self.has_key? key
            return true
        end
    end
    
    return false
end

#hash? ⇒ Boolean

Returns:

  • (Boolean) 


823
824
825
 
# File 'lib/hash-utils/hash.rb', line 823

def hash?
    true
end

#keys_to_sym ⇒ Object Also known as: symbolize_keys 



289
290
291
292
293
294
295
296
297
 
# File 'lib/hash-utils/hash.rb', line 289

def keys_to_sym
    self.map_keys do |k| 
        if k.kind_of? String
            k.to_sym 
        else
            k
        end
    end
end

#keys_to_sym! ⇒ Object Also known as: symbolize_keys! 



313
314
315
 
# File 'lib/hash-utils/hash.rb', line 313

def keys_to_sym!
    self.replace(self.keys_to_sym)
end

#ksort(&block) ⇒ Object 



420
421
422
423
424
425
 
# File 'lib/hash-utils/hash.rb', line 420

def ksort(&block)
    if block.nil?
       block = Proc::new { |a, b| a <=> b }
    end
    Hash[self.sort { |a, b| block.call(a[0], b[0]) }]
end

#ksort!(&block) ⇒ Object 



438
439
440
 
# File 'lib/hash-utils/hash.rb', line 438

def ksort!(&block)
    self.replace(self.ksort(&block))
end

#map_keys(&block) ⇒ Object Also known as: collect_keys 



210
211
212
213
214
 
# File 'lib/hash-utils/hash.rb', line 210

def map_keys(&block)
    self.map_pairs do |k, v|
        [block.call(k), v]
    end
end

#map_keys!(&block) ⇒ Object Also known as: collect_keys! 



231
232
233
 
# File 'lib/hash-utils/hash.rb', line 231

def map_keys!(&block)
    self.replace(self.map_keys(&block))
end

#map_pairs(&block) ⇒ Object Also known as: collect_pairs 



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

def map_pairs(&block)
    _new = self.recreate
    
    self.each_pair do |k, v|
        new_k, new_v = block.call(k, v)
        _new[new_k] = new_v
    end
    
    return _new
end

#map_pairs!(&block) ⇒ Object Also known as: collect_pairs! 



191
192
193
 
# File 'lib/hash-utils/hash.rb', line 191

def map_pairs!(&block)
    self.replace(self.map_pairs(&block))
end

#map_values(&block) ⇒ Object Also known as: collect_values 



250
251
252
253
254
 
# File 'lib/hash-utils/hash.rb', line 250

def map_values(&block)
    self.map_pairs do |k, v|
        [k, block.call(v)]
    end
end

#map_values!(&block) ⇒ Object Also known as: collect_values! 



271
272
273
 
# File 'lib/hash-utils/hash.rb', line 271

def map_values!(&block)
    self.replace(self.map_values(&block))
end

#recreate ⇒ Object 



58
59
60
 
# File 'lib/hash-utils/hash.rb', line 58

def recreate
    self.class::create(self.default, &self.default_proc)
end

#recreate! ⇒ Object 



72
73
74
 
# File 'lib/hash-utils/hash.rb', line 72

def recreate!
    self.replace(self.recreate)
end

#remove!(&block) ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/hash-utils/hash.rb', line 87

def remove!(&block)
    result = self.recreate
    delete = [ ]
    
    self.each_pair do |k, v|
        if block.call(k, v)
            result[k] = v
            delete << k
        end
    end
    
    delete.each do |k|
        self.delete(k)
    end
    
    return result
end

#reverse ⇒ Object 



492
493
494
 
# File 'lib/hash-utils/hash.rb', line 492

def reverse
    Hash[self.to_a.reverse]
end

#reverse! ⇒ Object 



505
506
507
 
# File 'lib/hash-utils/hash.rb', line 505

def reverse!
    self.replace(self.reverse)
end

#some?(&block) ⇒ Boolean

Returns:

  • (Boolean) 


359
360
361
362
363
 
# File 'lib/hash-utils/hash.rb', line 359

def some?(&block)
    self.one? do |pair|
        block.call(pair[1])
    end
end

#sort!(&block) ⇒ Object 



401
402
403
 
# File 'lib/hash-utils/hash.rb', line 401

def sort!(&block)
    self.replace(Hash[self.sort(&block)])
end

#sum ⇒ Object 



789
790
791
 
# File 'lib/hash-utils/hash.rb', line 789

def sum
    self.values.sum
end

#take_items(*args) ⇒ Object 



739
740
741
742
743
744
745
746
 
# File 'lib/hash-utils/hash.rb', line 739

def take_items(*args)
    result = { }
    self.take_pairs(*args) do |key, value|
        result[key] = value
    end
    
    return result
end

#take_pairs(*args) ⇒ Object 



717
718
719
720
721
 
# File 'lib/hash-utils/hash.rb', line 717

def take_pairs(*args)
    args.each do |i|
        yield [i, self[i]]
    end
end

#take_values(*args) ⇒ Object 



763
764
765
766
767
768
769
770
 
# File 'lib/hash-utils/hash.rb', line 763

def take_values(*args)
    result = [ ]
    self.take_pairs(*args) do |key, value|
        result << value
    end
    
    return result
end

#to_h(mode = nil) ⇒ Object 



387
388
389
 
# File 'lib/hash-utils/hash.rb', line 387

def to_h(mode = nil)
    self
end