Refactoring the Cacher interface to always require attribute declaration.

Previously you could dynamically use cached values, but the new interface
requires a single static declaration of the attribute:

    cached_attr(:myattr) { my_init_code() }

This is cleaner, because it makes it easy to turn the code into an init method
and generally makes the whole thing easier to think about.

Most of this commit is going through the different classes that already using the
Caching engine.

Signed-off-by: Luke Kanies <luke@madstop.com>

1 files changed, 43 insertions, 64 deletions

diff --git a/lib/puppet/util/cacher.rb b/lib/puppet/util/cacher.rb
index 139aa3659..0406b12f1 100644
--- a/lib/puppet/util/cacher.rb
+++ b/lib/puppet/util/cacher.rb
@@ -1,25 +1,30 @@
 module Puppet::Util::Cacher
-    # It's basically not possible to test that this is set,
-    # but we need to start with a value so that all initial values
-    # start out valid -- that is, everything's valid until the
-    # first call to 'expire'.
-    @timestamp = Time.now
+    module Expirer
+        attr_reader :timestamp
 
-    # Cause all cached values to be considered expired.
-    def self.expire
-        @timestamp = Time.now
-    end
+        # Cause all cached values to be considered expired.
+        def expire
+            @timestamp = Time.now
+        end
 
-    # Is the provided timestamp later than or equal to our global timestamp?
-    # If it is, then the associated value is valid, otherwise it should be flushed.
-    def self.valid?(timestamp)
-        return timestamp >= @timestamp
+        # Is the provided timestamp earlier than our expiration timestamp?
+        # If it is, then the associated value is expired.
+        def expired?(ts)
+            return false unless timestamp
+
+            return timestamp > ts
+        end
     end
 
+    extend Expirer
+
     # Our module has been extended in a class; we can only add the Instance methods,
     # which become *class* methods in the class.
     def self.extended(other)
-        other.extend(InstanceMethods)
+        class << other
+            extend ClassMethods
+            include InstanceMethods
+        end
     end
 
     # Our module has been included in a class, which means the class gets the class methods
@@ -40,72 +45,46 @@ module Puppet::Util::Cacher
             define_method(init_method, &block)
 
             define_method(name) do
-                cacher_caches.value(name) { send(init_method) }
+                cached_value(name)
             end
         end
     end
 
     # Methods that get added to instances.
     module InstanceMethods
-        private
-
-        # Use/define a cached value.  We just use the Cache class to do all
-        # of the thinking.  Note that we're using a single Cache instance
-        # for all of this instance's cached values.
-        def attr_cache(name, &block)
-            cacher_caches.value(name, &block)
-        end
-
-        def cacher_caches
-            unless defined?(@cacher_caches) and @cacher_caches
-                @cacher_caches = Cache.new
-            end
-            @cacher_caches
+        def expire
+            expirer.expire
         end
-    end
-
-    # An internal class that does all of our comparisons and calculations.
-    # This both caches a given value, and determines whether a given cache is
-    # still valid.
-    class Cache
-        attr_accessor :caches, :timestamp
 
-        def clear
-            caches.clear
-            self.timestamp = Time.now
+        def expirer
+            Puppet::Util::Cacher
         end
 
-        def initialize
-            @caches = {}
-            @timestamp = Time.now
-        end
+        private
 
-        # If our timestamp is out of date, our cached data is expired.
-        def expired?
-            ! Puppet::Util::Cacher.valid?(timestamp)
+        def cache_timestamp
+            unless defined?(@cache_timestamp)
+                @cache_timestamp = Time.now
+            end
+            @cache_timestamp
         end
 
-        # Return a value; use the cached version if the associated timestamp is recent enough,
-        # else calculate and store a new a value using the provided block.
-        def value(name)
-            raise ArgumentError, "You must provide a block when using the cache" unless block_given?
-
-            # If the cached data is expired, clear the cache and get a new
-            # value.  Note that if we clear the cache here, we potentially
-            # clear other cached values, too (if this instance is caching more
-            # than one value).
-            if expired?
-                clear
+        def cached_value(name)
+            if expirer.expired?(cache_timestamp)
+                value_cache.clear
+                @cache_timestamp = Time.now
             end
-
-            # Generate a new value if we don't have one.  Use 'include?' here
-            # rather than testing for truth, so we can cache false values.
-            unless caches.include?(name)
-                caches[name] = yield
+            unless value_cache.include?(name)
+                value_cache[name] = send("init_%s" % name)
             end
+            value_cache[name]
+        end
 
-            # Finally, return our cached value.
-            caches[name]
+        def value_cache
+            unless defined?(@value_cache) and @value_cache
+                @value_cache = {}
+            end
+            @value_cache
         end
     end
 end