Class: Perennial::Nash

Inherits:
Object show all
Defined in:
lib/perennial/nash.rb

Overview

A ninja hash. Like OpenStruct, but better

Constant Summary collapse

@@parse_times = 
true

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(initial = {}) ⇒ Nash

Returns a new instance of Nash.



25
26
27
28
29
30
31
 
# File 'lib/perennial/nash.rb', line 25

def initialize(initial = {})
  @table = {}
  initial.to_hash.each_pair do |k,v|
    v = Time.parse(v) if @@parse_times && k.to_s =~ /_at$/ && v.is_a?(String)
    self[k] = v
  end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &blk) ⇒ Object (protected) 



203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/perennial/nash.rb', line 203

def method_missing(name, *args, &blk)
  name = name.to_s
  case name.to_s[-1]
  when ??
    self[name[0..-2]].present?
  when ?=
    send(:[]=, real_key(name[0..-2]), *args)
  when ?!
    self[name[0..-2]] = self.class.new
  else
    self[name]
  end
end

Instance Attribute Details

#table ⇒ Object (readonly)

Returns the value of attribute table.



23
24
25
 
# File 'lib/perennial/nash.rb', line 23

def table
  @table
end

Class Method Details

.load_file(path) ⇒ Object 



11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/perennial/nash.rb', line 11

def self.load_file(path)
  n = self.new
  if File.file?(path) && File.readable?(path)
    contents = YAML.load_file(path)
  end
  if contents.is_a?(Hash)
    contents.to_nash
  else
    new(:data => contents).normalized
  end
end

Instance Method Details

#[](key) ⇒ Object 



33
34
35
 
# File 'lib/perennial/nash.rb', line 33

def [](key)
  @table[real_key(key)]
end

#[]=(key, *values) ⇒ Object 



37
38
39
 
# File 'lib/perennial/nash.rb', line 37

def []=(key, *values)
  @table.send(:[]=, real_key(key), *values)
end

#_inspect ⇒ Object 



144
145
146
147
148
149
150
151
152
 
# File 'lib/perennial/nash.rb', line 144

def _inspect
  str = "#<Perennial::Nash:#{(object_id * 2).to_s(16)}"
  if !blank?
    str << " "
    str << table.map { |k, v| "#{k}=#{v.inspect}" }.join(", ")
  end
  str << ">"
  return str
end

#blank? ⇒ Boolean

Returns:

  • (Boolean) 


118
119
120
 
# File 'lib/perennial/nash.rb', line 118

def blank?
  @table.blank?
end

#delete(key) ⇒ Object 



85
86
87
 
# File 'lib/perennial/nash.rb', line 85

def delete(key)
  @table.delete(real_key(key))
end

#dup ⇒ Object 



49
50
51
 
# File 'lib/perennial/nash.rb', line 49

def dup
  Nash.new(self.table)
end

#each_key ⇒ Object 



77
78
79
 
# File 'lib/perennial/nash.rb', line 77

def each_key
  @table.each_key { |k| yield k }
end

#each_pair ⇒ Object 



73
74
75
 
# File 'lib/perennial/nash.rb', line 73

def each_pair
  @table.each_pair { |k, v| yield k, v }
end

#each_value ⇒ Object 



81
82
83
 
# File 'lib/perennial/nash.rb', line 81

def each_value
  @table.each_value { |v| yield v }
end

#has_key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


65
66
67
 
# File 'lib/perennial/nash.rb', line 65

def has_key?(key)
  @table.has_key? real_key(key)
end

#has_value?(value) ⇒ Boolean

Returns:

  • (Boolean) 


69
70
71
 
# File 'lib/perennial/nash.rb', line 69

def has_value?(value)
  @table.has_value? value
end

#hash ⇒ Object 



154
155
156
 
# File 'lib/perennial/nash.rb', line 154

def hash
  @table.hash
end

#id ⇒ Object 



45
46
47
 
# File 'lib/perennial/nash.rb', line 45

def id
  self.has_key?(:id) ? self.id : super
end

#inspect ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/perennial/nash.rb', line 126

def inspect
  str = ""
  if Thread.current[:inspect_stack].nil?
    Thread.current[:inspect_stack] = [self]
    str = _inspect
    Thread.current[:inspect_stack] = nil
  else
    if Thread.current[:inspect_stack].include?(self)
      return "..."
    else
      Thread.current[:inspect_stack] << self
      str = _inspect
      Thread.current[:inspect_stack].pop
    end
  end
  return str
end

#keys ⇒ Object 



57
58
59
 
# File 'lib/perennial/nash.rb', line 57

def keys
  @table.keys
end

#merge(hash_or_nash) ⇒ Object 



96
97
98
 
# File 'lib/perennial/nash.rb', line 96

def merge(hash_or_nash)
  dup.merge! hash_or_nash
end

#merge!(hash_or_nash) ⇒ Object 



89
90
91
92
93
94
 
# File 'lib/perennial/nash.rb', line 89

def merge!(hash_or_nash)
  hash_or_nash.to_hash.each_pair do |k, v|
    self[k] = v
  end
  return self
end

#normalized(n = nil) ⇒ Object 



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/perennial/nash.rb', line 158

def normalized(n = nil)
  item = nil
  if Thread.current[:normalized].nil?
    n = self.class.new
    Thread.current[:normalized] = {self => n}
    item = normalize_nash(n)
    Thread.current[:normalized] = nil
  else
    if Thread.current[:normalized].has_key?(self)
      return Thread.current[:normalized][self]
    else
      n = self.class.new
      Thread.current[:normalized][self] = n
      item = normalize_nash(n)
    end
  end
  item
end

#present? ⇒ Boolean

Returns:

  • (Boolean) 


122
123
124
 
# File 'lib/perennial/nash.rb', line 122

def present?
  @table.present?
end

#replace(nash) ⇒ Object 



108
109
110
111
112
113
114
115
116
 
# File 'lib/perennial/nash.rb', line 108

def replace(nash)
  if nash.is_a?(self.class)
    @table = nash.table
  else
    @table = {}
    nash.to_hash.each_pair { |k, v| self[k] = v }
  end
  return self
end

#respond_to?(name, rec = nil) ⇒ Boolean

Returns:

  • (Boolean) 


41
42
43
 
# File 'lib/perennial/nash.rb', line 41

def respond_to?(name, rec = nil)
  true
end

#reverse_merge(hash_or_nash) ⇒ Object 



104
105
106
 
# File 'lib/perennial/nash.rb', line 104

def reverse_merge(hash_or_nash)
  dup.reverse_merge(hash_or_nash)
end

#reverse_merge!(hash_or_nash) ⇒ Object 



100
101
102
 
# File 'lib/perennial/nash.rb', line 100

def reverse_merge!(hash_or_nash)
  replace Nash.new(hash_or_nash).merge!(self)
end

#to_hash ⇒ Object 



53
54
55
 
# File 'lib/perennial/nash.rb', line 53

def to_hash
  @table.dup
end

#to_nash ⇒ Object 



177
178
179
 
# File 'lib/perennial/nash.rb', line 177

def to_nash
  self
end

#values ⇒ Object 



61
62
63
 
# File 'lib/perennial/nash.rb', line 61

def values
  @table.values
end