Class: Perennial::Nash

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

Overview

A ninja hash. Like OpenStruct, but better

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(initial = {}) ⇒ Nash

Returns a new instance of Nash.



20
21
22
23
 
# File 'lib/perennial/nash.rb', line 20

def initialize(initial = {})
  @table = {}
  initial.to_hash.each_pair { |k,v| self[k] = v }
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

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



191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'lib/perennial/nash.rb', line 191

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.



18
19
20
 
# File 'lib/perennial/nash.rb', line 18

def table
  @table
end

Class Method Details

.load_file(path) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# File 'lib/perennial/nash.rb', line 6

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 



25
26
27
 
# File 'lib/perennial/nash.rb', line 25

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

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



29
30
31
 
# File 'lib/perennial/nash.rb', line 29

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

#_inspect ⇒ Object 



136
137
138
139
140
141
142
143
144
 
# File 'lib/perennial/nash.rb', line 136

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) 


110
111
112
 
# File 'lib/perennial/nash.rb', line 110

def blank?
  @table.blank?
end

#delete(key) ⇒ Object 



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

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

#dup ⇒ Object 



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

def dup
  Nash.new(self.table)
end

#each_key ⇒ Object 



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

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

#each_pair ⇒ Object 



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

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

#each_value ⇒ Object 



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

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

#has_key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#has_value?(value) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#hash ⇒ Object 



146
147
148
 
# File 'lib/perennial/nash.rb', line 146

def hash
  @table.hash
end

#id ⇒ Object 



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

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

#inspect ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/perennial/nash.rb', line 118

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 



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

def keys
  @table.keys
end

#merge(hash_or_nash) ⇒ Object 



88
89
90
 
# File 'lib/perennial/nash.rb', line 88

def merge(hash_or_nash)
  dup.merge! hash_or_nash
end

#merge!(hash_or_nash) ⇒ Object 



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

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 



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/perennial/nash.rb', line 150

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) 


114
115
116
 
# File 'lib/perennial/nash.rb', line 114

def present?
  @table.present?
end

#replace(nash) ⇒ Object 



100
101
102
103
104
105
106
107
108
 
# File 'lib/perennial/nash.rb', line 100

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) 


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

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

#reverse_merge(hash_or_nash) ⇒ Object 



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

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

#reverse_merge!(hash_or_nash) ⇒ Object 



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

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

#to_hash ⇒ Object 



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

def to_hash
  @table.dup
end

#values ⇒ Object 



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

def values
  @table.values
end