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 



605
606
607
608
609
610
611
612
 
# File 'lib/hash-utils/hash.rb', line 605

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

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



43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/hash-utils/hash.rb', line 43

def self.create(default = nil, hash = nil, &block)
    if not hash.nil?
        hash = hash.dup
    else
        hash = { }
    end
    
    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) 


362
363
364
365
366
367
368
369
370
371
372
 
# File 'lib/hash-utils/hash.rb', line 362

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 



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

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 



510
511
512
 
# File 'lib/hash-utils/hash.rb', line 510

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

#avg ⇒ Object Also known as: average 



841
842
843
 
# File 'lib/hash-utils/hash.rb', line 841

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



141
142
143
 
# File 'lib/hash-utils/hash.rb', line 141

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



154
155
156
 
# File 'lib/hash-utils/hash.rb', line 154

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

#deep_merge(*args) ⇒ Object 



654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
 
# File 'lib/hash-utils/hash.rb', line 654

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 



625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
 
# File 'lib/hash-utils/hash.rb', line 625

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

#first_key ⇒ Object 



923
924
925
926
 
# File 'lib/hash-utils/hash.rb', line 923

def first_key
    first = self.first
    first ? first.first : nil
end

#first_value ⇒ Object 



937
938
939
940
 
# File 'lib/hash-utils/hash.rb', line 937

def first_value
    first = self.first
    first ? first.second : nil
end

#flip ⇒ Object 



872
873
874
 
# File 'lib/hash-utils/hash.rb', line 872

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

#flip! ⇒ Object 



886
887
888
 
# File 'lib/hash-utils/hash.rb', line 886

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

#get_items(*args) ⇒ Object 



708
709
710
711
712
713
714
715
 
# File 'lib/hash-utils/hash.rb', line 708

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

#get_pairs(*args) ⇒ Object 



684
685
686
687
688
689
690
 
# File 'lib/hash-utils/hash.rb', line 684

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

#get_values(*args) ⇒ Object 



731
732
733
734
735
736
737
738
 
# File 'lib/hash-utils/hash.rb', line 731

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) 


553
554
555
556
557
558
559
560
561
 
# File 'lib/hash-utils/hash.rb', line 553

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) 


577
578
579
580
581
582
583
584
585
 
# File 'lib/hash-utils/hash.rb', line 577

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

#hash? ⇒ Boolean

Returns:

  • (Boolean) 


858
859
860
 
# File 'lib/hash-utils/hash.rb', line 858

def hash?
    true
end

#keys_to_sym ⇒ Object Also known as: symbolize_keys 



315
316
317
318
319
320
321
322
323
 
# File 'lib/hash-utils/hash.rb', line 315

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! 



339
340
341
 
# File 'lib/hash-utils/hash.rb', line 339

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

#ksort(&block) ⇒ Object 



454
455
456
457
458
459
 
# File 'lib/hash-utils/hash.rb', line 454

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 



472
473
474
 
# File 'lib/hash-utils/hash.rb', line 472

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

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



236
237
238
239
240
 
# File 'lib/hash-utils/hash.rb', line 236

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! 



257
258
259
 
# File 'lib/hash-utils/hash.rb', line 257

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

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



191
192
193
194
195
196
197
198
199
200
 
# File 'lib/hash-utils/hash.rb', line 191

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! 



217
218
219
 
# File 'lib/hash-utils/hash.rb', line 217

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

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



276
277
278
279
280
 
# File 'lib/hash-utils/hash.rb', line 276

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! 



297
298
299
 
# File 'lib/hash-utils/hash.rb', line 297

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

#recreate ⇒ Object 



84
85
86
 
# File 'lib/hash-utils/hash.rb', line 84

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

#recreate! ⇒ Object 



98
99
100
 
# File 'lib/hash-utils/hash.rb', line 98

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

#remove!(&block) ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/hash-utils/hash.rb', line 113

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 



526
527
528
 
# File 'lib/hash-utils/hash.rb', line 526

def reverse
    Hash[self.to_a.reverse]
end

#reverse! ⇒ Object 



539
540
541
 
# File 'lib/hash-utils/hash.rb', line 539

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

#some?(&block) ⇒ Boolean

Returns:

  • (Boolean) 


385
386
387
388
389
390
391
 
# File 'lib/hash-utils/hash.rb', line 385

def some?(&block)
    self.each_value do |v|
        return true if block.call(v)
    end
    
    return false
end

#some_pairs?(&block) ⇒ Boolean

Returns:

  • (Boolean) 


404
405
406
407
408
409
410
 
# File 'lib/hash-utils/hash.rb', line 404

def some_pairs?(&block)
    self.each_pair do |pair|
        return true if block.call(pair)
    end
    
    return false
end

#sort!(&block) ⇒ Object 



435
436
437
 
# File 'lib/hash-utils/hash.rb', line 435

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

#sum ⇒ Object 



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

def sum
    self.values.sum
end

#take_items(*args) ⇒ Object 



773
774
775
776
777
778
779
780
 
# File 'lib/hash-utils/hash.rb', line 773

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

#take_pairs(*args) ⇒ Object 



751
752
753
754
755
 
# File 'lib/hash-utils/hash.rb', line 751

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

#take_values(*args) ⇒ Object 



797
798
799
800
801
802
803
804
 
# File 'lib/hash-utils/hash.rb', line 797

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

#to_h(mode = nil) ⇒ Object 



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

def to_h(mode = nil)
    self
end