Class: Hash

Inherits:
Object
  • Object
show all
Defined in:
lib/rake/pro/hashex.rb

Instance Method Summary collapse

Instance Method Details

#key_details(k) ⇒ Object

CASE

admin@dev,prod:
   username: abc
   password

returns 

scopes  : [dev, prod]
sub_key : admin
admin:
   username: abc

CASE: dev:

url:  abc

returns

scopes: [dev]
subkey: nil

CASE:

url@dev: abc

returns:

scopes: [dev]
subkey: url

CASE:

dev:
    url:  abc


74
75
76
77
78
79
80
81
 
# File 'lib/rake/pro/hashex.rb', line 74

def key_details(k)
  subkey = scopes = nil
  sk = k.to_s
  skp = sk.split('@')
  subkey = skp.shift.to_sym if (skp.length > 1)
  scopes = skp[0].split(/\s*[&,\|]\s*/)
  [scopes.map { |scope| scope.to_sym }, subkey]
end

#match(strings) ⇒ Object 


26
27
28
29
30
31
32
33
34
 
# File 'lib/rake/pro/hashex.rb', line 26

def match strings
  select { |key,val|
    is_match = false
    strings.each { |findstr|
      is_match ||= key.downcase.include?(findstr) || val.downcase.include?(findstr)
    }
    is_match
  }
end

#promote_key(pk) ⇒ Object 


83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/rake/pro/hashex.rb', line 83

def promote_key pk
  pk = pk.to_sym
  coh = {}
  promoted = false
  self.each_pair { |k, v|
    scopes, subkey = key_details(k)
    if (scopes.include?(pk))
      promoted = true
      if subkey.nil?
        v.each_pair { |sk, sv|
          coh[sk] = sv
        }
        coh[k] = v
      else
        coh[subkey] =v
      end
    else
      if v.is_a?(Hash)
        coh[k], subpromo = v.promote_key(pk)
        promoted |= subpromo
      else
        coh[k] = v
      end
    end
  }
  [coh, promoted]
end

#prune_keys(pks) ⇒ Object 


111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/rake/pro/hashex.rb', line 111

def prune_keys pks
  coh = {}
  self.each_pair { |k, v|
    scopes, subkey = key_details(k)
    prune = false
    scopes.each { |scope| prune |= pks.include?(scope) }
    if prune
      scopes.each { |scope|
        if !pks.include?(scope)
          if (subkey.nil?)
            coh[scope] = v
          else
            coh[scope] = {}
            coh[scope][subkey] = v
          end
        end
      }
    else
      coh[k] = v.is_a?(Hash) ? v.prune_keys(pks) : v
    end
  }
  coh
end

#recursive_merge(new_hash) ⇒ Object 


2
3
4
5
6
7
8
9
10
11
12
 
# File 'lib/rake/pro/hashex.rb', line 2

def recursive_merge(new_hash)
  self.merge(new_hash) do |k, old_val, new_val|
    if new_val.respond_to?(:blank) && new_val.blank?
      old_val
    elsif (old_val.kind_of?(Hash) and new_val.kind_of?(Hash))
      old_val.recursive_merge(new_val)
    else
      new_val
    end
  end
end

#recursive_merge!(new_hash) ⇒ Object 


14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/rake/pro/hashex.rb', line 14

def recursive_merge!(new_hash)
  self.merge!(new_hash) do |k, old_val, new_val|
    if new_val.respond_to?(:blank) && new_val.blank?
      old_val
    elsif (old_val.kind_of?(Hash) and new_val.kind_of?(Hash))
      old_val.recursive_merge!(new_val)
    else
      new_val
    end
  end
end

#symbolize_keys ⇒ Object 


36
37
38
39
40
41
 
# File 'lib/rake/pro/hashex.rb', line 36

def symbolize_keys
  inject({}) { |memo,(k,v)| 
    memo[k.to_sym] = v.is_a?(Hash) ? v.symbolize_keys : v;
    memo
  }
end