Add support for globally resetting all ttl memoized values (#15)

Track an index which causes immediate reset of memoized values every
time it is incremented.

lib/ttl_memoizeable.rb

@@ -9,12 +9,17 @@ module TTLMemoizeable
   TTLMemoizationError = Class.new(StandardError)
   SetupMutex = Mutex.new
 
+  @ttl_index = 0
   @disabled = false
 
   def self.disable!
     @disabled = true
   end
 
+  def self.reset!
+    @ttl_index += 1
+  end
+
   def ttl_memoized_method(method_name, ttl: 1000)
     raise TTLMemoizationError, "Method not defined: #{method_name}" unless method_defined?(method_name) || private_method_defined?(method_name)
 
@@ -23,6 +28,7 @@ def ttl_memoized_method(method_name, ttl: 1000)
     expired_ttl = time_based_ttl ? 1.year.ago : 1
 
     ttl_variable_name = :"@_ttl_for_#{ivar_name}"
+    ttl_index_variable_name = :"@_ttl_index_for_#{ivar_name}"
     mutex_variable_name = :"@_mutex_for_#{ivar_name}"
     value_variable_name = :"@_value_for_#{ivar_name}"
 
@@ -67,6 +73,7 @@ def ttl_memoized_method(method_name, ttl: 1000)
 
       define_method ttl_exceeded_method_name do
         return true if TTLMemoizeable.instance_variable_get(:@disabled)
+        return true if TTLMemoizeable.instance_variable_get(:@ttl_index) != instance_variable_get(ttl_index_variable_name)
         return true unless instance_variable_defined?(value_variable_name)
 
         compared_to = time_based_ttl ? ttl.ago : 0
@@ -92,6 +99,9 @@ def ttl_memoized_method(method_name, ttl: 1000)
           if send(ttl_exceeded_method_name)
             send(extend_ttl_method_name)
 
+            # Synchronize the ttl index to match the module's value
+            instance_variable_set(ttl_index_variable_name, TTLMemoizeable.instance_variable_get(:@ttl_index))
+
             # Refresh value from the original method
             instance_variable_set(value_variable_name, super())
           end

spec/ttl_memoizeable_spec.rb

@@ -347,4 +347,28 @@ def bar
       end
     end
   end
+
+  describe ".reset!" do
+    context "expires all ttls" do
+      let(:klass) { integer_ttl_klass }
+
+      it "only calls #expensive_bar twice" do
+        expect(Klass).to receive(:expensive_bar).and_call_original.exactly(3)
+
+        expect(Klass.bar).to eq(1) # first expensive_bar
+
+        described_class.reset!
+        expect(Klass.bar).to eq(1) # second expensive_bar
+        2.times do
+          expect(Klass.bar).to eq(1)
+        end
+
+        described_class.reset!
+        expect(Klass.bar).to eq(1) # third expensive_bar
+        8.times do
+          expect(Klass.bar).to eq(1)
+        end
+      end
+    end
+  end
 end