Module: Gibbler::Object

Included in:
Class, Array, Complex, DateTime, File, Hash, Nil, Range, String, Time, Module, Proc
Defined in:
lib/gibbler.rb,
lib/gibbler/aliases.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.gibbler_fields ⇒ Object 



140
141
 
# File 'lib/gibbler.rb', line 140

def self.gibbler_fields
end

.included(obj) ⇒ Object 



133
134
135
136
137
138
 
# File 'lib/gibbler.rb', line 133

def self.included(obj)
  obj.extend Attic
  obj.attic :gibbler_cache
  # Backwards compatibility for <= 0.6.2 
  obj.send :alias_method, :__gibbler_cache, :gibbler_cache
end

Instance Method Details

#__gibbler(digest_type = nil) ⇒ Object

Creates a digest for the current state of self based on:

  • Object#class

  • Length of Object#name || 0

  • Object#name || ”

e.g. Digest::SHA1.hexdigest “Class:6:Object” #=>

This is a default method appropriate for only the most basic objects like Class and Module.



194
195
196
197
198
199
200
201
 
# File 'lib/gibbler.rb', line 194

def __gibbler(digest_type=nil)
  klass = self.class
  nom = self.name if self.respond_to?(:name)
  nom ||= ''
  a = Gibbler.digest '%s:%s:%s' % [klass, nom.size, nom], digest_type
  gibbler_debug klass, a, [klass, nom.size, nom]
  a
end

#digest_cache ⇒ Object

The cache is in the Attic.



12
 
# File 'lib/gibbler/aliases.rb', line 12

def    digest_cache;     gibbler_cache;  end

#freeze ⇒ Object

A simple override on Object#freeze to create a digest before the object is frozen. Once the object is frozen obj.gibbler will return the cached value with out calculation.



207
208
209
210
211
212
 
# File 'lib/gibbler.rb', line 207

def freeze()
  gibbler_debug :FREEZE, self.class, caller[0] if Gibbler.debug?
  self.gibbler
  super
  self
end

#gibbled? ⇒ Boolean Also known as: changed?

Has this object been modified?

This method compares the return value from digest with the previous value returned by gibbler (the value is stored in the attic as gibbler_cache). See Attic

Returns:

  • (Boolean) 


172
173
174
175
176
177
 
# File 'lib/gibbler.rb', line 172

def gibbled?
  self.gibbler_cache ||= self.gibbler
  was, now = self.gibbler_cache.clone, self.gibbler
  gibbler_debug :gibbled?, was, now
  was != now
end

#gibbler(digest_type = nil) ⇒ Object Also known as: digest

Calculates a digest for the current object instance. Objects that are a kind of Hash or Array are processed recursively. The length of the returned String depends on the digest type. Also stores the value in the attic.

obj.gibbler          # => a5b1191a
obj.gibbler_cache    # => a5b1191a

Calling gibbler_cache returns the most recent digest without calculation.

If the object is frozen, this will return the value of gibbler_cache.



159
160
161
162
163
164
 
# File 'lib/gibbler.rb', line 159

def gibbler(digest_type=nil)
  #gibbler_debug caller[0]
  gibbler_debug :GIBBLER, self.class, self
  return self.gibbler_cache if self.frozen?
  self.gibbler_cache = Gibbler::Digest.new self.__gibbler(digest_type)
end

#gibbler_debug(*args) ⇒ Object 



179
180
181
182
 
# File 'lib/gibbler.rb', line 179

def gibbler_debug(*args)
  return unless Gibbler.debug?
  p args
end

#gibbler_fields ⇒ Object Also known as: digest_fields 



142
143
 
# File 'lib/gibbler.rb', line 142

def gibbler_fields
end