cached_values 1.0.0

data/History.txt

@@ -0,0 +1,3 @@
+=== 1.0.0 / 2008-03-06
+
+* Converted from a Rails plugin

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,17 @@
+History.txt
+MIT-LICENSE
+Manifest.txt
+README.txt
+Rakefile
+init.rb
+install.rb
+lib/cached_values.rb
+lib/cached_values/cached_value.rb
+lib/cached_values/caches_value.rb
+tasks/cached_values_tasks.rake
+test/database.yml
+test/leprechaun.rb
+test/schema.rb
+test/test_cached_values.rb
+test/test_helper.rb
+uninstall.rb

data/README.txt

@@ -0,0 +1,66 @@
+= Cached Values
+
+* http://github.com/JackDanger/cached_values/
+
+A dead-simple way to calculate any value via Ruby or SQL and (optionally) have it saved in a database field.
+
+== REQUIREMENTS:
+
+* ObjectProxy
+
+== INSTALL:
+
+* as gem: sudo gem install cached_values
+* as plugin: ./script/plugin install git://github.com/JackDanger/cached_values.git
+
+== USAGE:
+
+You can calculate values with a single line in any ActiveRecord model.  To actually save those values you'll need to create
+an attribute in your schema.  By default the cached_value instance will look for an attribute with the same name as itself.
+You can override this by specifying a :cache => :some_attribute option
+
+A very simple case in which cached_values works just like the .count method on a has_many association:
+
+  class Leprechaun < ActiveRecord::Base
+   caches_value :total_gold_coins, :sql => 'select count(*) from gold_coins where leprechaun_id = #{id}'
+  end
+  
+  Company.find(4).total_employees # => 45
+
+A more sophisticated example:
+
+  class Leprechaun < ActiveRecord::Base
+   has_many :lucky_charms
+   has_many :deceived_children, :through => :lucky_charms
+   caches_value :total_children_remaining_to_be_deceived, :sql => '... very complicated sql here ...'
+  end
+  
+  Leprechaun.find(14).total_children_remaining_to_be_deceived # => 6,692,243,122
+
+The values can be of any type.  The plugin will attempt to cast SQL results to the type corresponding with their database cache
+but calculations in Ruby are left alone.
+
+You can also calculate the value in Ruby using a string to be eval'ed or a Proc.  Both are evaluated
+in the context of the record instance.
+
+  class Leprechaun < ActiveRecord::Base
+    caches_value :total_gold, :eval => "some_archaic_and_silly_calculation(self.gold_coins)"
+    caches_value :total_lucky_charms, :eval => Proc.new {|record| record.calculate_total_lucky_charms }
+  end
+
+The cache is customizable, you can specify which attribute should be used as a cache:
+  
+  caches_value :runic_formula, :sql => '...'          # uses 'full_formula' column if it exists
+  caches_value :standard_deviation_of_gold_over_time, # uses 'std' column if it exists
+               :sql => '...', :cache => 'std'
+  caches_value :id, :sql => '...', :cache => false    # does NOT save any cache.  This avoids overwriting an attribute
+
+ActiveRecord callbacks can be used to call load (make sure the value is in memory), clear (flush the cache and
+delete the instance), or reload (flush cache and reload instance) at certain times:
+  
+  caches_value :standard_deviation, :sql => '...', :reload => [:after_save, :before_validation]
+  caches_value :full_formula, :sql => '...', :clear => :after_find
+
+Bugs can be filed at http://code.lighthouseapp.com/projects/4502-hoopla-rails-plugins/
+
+Copyright (c) 2007 Jack Danger Canty @ http://6brand.com, released under the MIT license

data/Rakefile

@@ -0,0 +1,17 @@
+# -*- ruby -*-
+
+$:.unshift(File.dirname(__FILE__) + '/lib')
+$:.unshift(File.dirname(__FILE__) + '/lib/cached_values')
+
+
+require 'rubygems'
+require 'hoe'
+require "cached_values"
+
+Hoe.new('cached_values', CachedValues::VERSION) do |p|
+  p.rubyforge_name = 'cachedvalues' # if different than lowercase project name
+  p.remote_rdoc_dir = '' # Release to root
+  p.developer('Jack Danger Canty', 'rubygems_cached_values@6brand.com')
+end
+
+# vim: syntax=Ruby

data/init.rb

@@ -0,0 +1,3 @@
+require 'cached_value'
+require 'cached_values'
+ActiveRecord::Base.send :include, CachedValues

data/install.rb

@@ -0,0 +1 @@
+puts IO.read(File.join(File.dirname(__FILE__), 'README.txt'))

data/lib/cached_values/cached_value.rb

@@ -0,0 +1,145 @@
+require 'object_proxy'
+  
+module ActiveRecord
+  class CachedValue < ObjectProxy
+
+    def initialize(owner, reflection)
+      @owner, @reflection = owner, reflection
+      reset
+    end
+    
+    def reset
+      @target = nil
+      @loaded = false
+    end
+
+    def load
+      reset
+      load_target
+    end
+
+    def reload
+      @owner.instance_variable_set("@#{@reflection.name}", nil)
+      reset
+      @target = find_target(true)
+      @owner.send @reflection.name
+    end
+    
+    alias update reload
+    
+    def clear
+      clear_cache
+      @owner.instance_variable_set("@#{@reflection.name}", nil)
+    end
+
+    def loaded?
+      @loaded
+    end
+    
+    def loaded
+      @loaded = true
+    end
+    
+    def target
+      @target
+    end
+
+    protected
+      
+      def load_target
+        return nil unless defined?(@loaded)
+        @target = find_target unless loaded?
+        @loaded = true
+        @target
+      end
+
+      def find_target(skip_cache = false)
+        target = find_target_from_cache unless skip_cache
+        unless target
+          target ||= @reflection.options[:sql] ? find_target_by_sql : find_target_by_eval
+          update_cache(target)
+        end
+        target
+      end
+      
+      def find_target_from_cache
+        @owner.send(:read_attribute, cache_column) if has_cache?
+      end
+      
+      def find_target_by_sql
+        sql = sanitize_sql(interpolate_sql(@reflection.options[:sql]))
+        result = @owner.class.connection.select_value(sql)
+        result = typecast_result(result)
+        result
+      end
+    
+      def find_target_by_eval
+        if @reflection.options[:eval].is_a?(String)
+          eval(@reflection.options[:eval], @owner.send(:binding))
+        elsif @reflection.options[:eval].is_a?(Proc)
+          @reflection.options[:eval].call(@owner)
+        elsif @reflection.options[:eval].is_a?(Symbol)
+          @owner.send @reflection.options[:eval]
+        else
+          raise ArgumentError.new("The :eval option on a cached_values must be a String or a Proc or a Symbol")
+        end
+      end
+      
+      def cache_column
+        @reflection.options[:cache]
+      end
+
+      def has_cache?
+        @reflection.options[:cache] && @owner.attribute_names.include?(@reflection.options[:cache].to_s)
+      end
+      
+      def clear_cache
+        update_cache(nil)
+      end
+      
+      def update_cache(value)
+        return unless has_cache?
+        unless @owner.new_record?
+          @owner.class.update_all(["#{cache_column} = ?", value], ["id = ?", @owner.id])
+        end
+        @owner.send(:write_attribute, cache_column, value)
+      end
+      
+      def typecast_result(result)
+        if has_cache?
+          typecast_sql_result_by_cache_column_type(result)
+        else
+          if result =~ /^\d+\.\d+$/
+            result.to_f
+          elsif result =~ /^\d+$/
+            result.to_i
+          else
+            result
+          end
+        end
+      end
+      
+      def typecast_sql_result_by_cache_column_type(result)
+        type = @owner.column_for_attribute(cache_column).type
+        case type
+        when :integer
+          result.to_i
+        when :float
+          result.to_f
+        when :boolean
+          [0,'0', 'NULL', 'nil', 'false', '', 'FALSE', 'False'].include?(result)
+        else
+          result
+        end
+      end
+      
+      def interpolate_sql(sql, record = nil)
+        @owner.send(:interpolate_sql, sql, record)
+      end
+
+      def sanitize_sql(sql)
+        @owner.class.send(:sanitize_sql, sql)
+      end
+      
+  end
+end

data/lib/cached_values/caches_value.rb

@@ -0,0 +1,104 @@
+require 'active_record'
+require File.expand_path(File.dirname(__FILE__) + '/cached_value')
+
+module CachesValues # :nodoc:
+  
+  def self.included(base)
+    unless base.extended_by.include?(CachesValues::ClassMethods)
+      base.extend(ClassMethods)
+    end
+  end
+
+  module ClassMethods
+    # USAGE:
+    #  
+    # a very simple case in which cached_values works just like the .count method on a has_many association:
+    #   
+    #   class Company < ActiveRecord::Base
+    #     caches_value :total_employees, :sql => 'select count(*) from employees where company_id = #{id}'
+    #   end
+    #  
+    # a more sophisticated example:
+    #  
+    #   class User < ActiveRecord::Base
+    #     has_many :trinkets
+    #     has_many :sales, :through => :trinkets
+    #     caches_value :remaining_trinket_sales_allotted, :sql => '... very complicated sql here ...'
+    #   end
+    #  
+    #   user = User.find(:first)
+    #   user.remaining_trinket_sales_allotted # => 70
+    #   Trinket.delete_all # <= any operation that would affect our value
+    #   user.remaining_trinket_sales_allotted # => 70
+    #   user.remaining_trinket_sales_allotted.reload # => 113
+    #  
+    # You can also calculate the value in Ruby.  This can be done by a string to be eval'ed or a Proc.  Both are evaluated
+    # in the context of the record instance.
+    #  
+    #   class User < ActiveRecord::Base
+    #     caches_value :expensive_calculation, :eval => "some_big_expensize_calculation(self.id)"
+    #     caches_value :other_expensive_process, :eval => Proc.new {|record| record.other_expensize_process }
+    #   end
+    #
+    
+    def caches_value(name, options = {})
+      reflection = create_cached_value_reflection(name, options)
+
+      configure_dependency_for_cached_value(reflection)
+
+      reflection.options[:cache] ||= reflection.name unless false == options[:cache]
+
+      cached_value_accessor_method(reflection, ActiveRecord::CachedValue)
+      cached_value_callback_methods(reflection)
+    end
+
+    private
+    
+      def configure_dependency_for_cached_value(reflection)
+      
+        if !reflection.options[:sql] && !reflection.options[:eval]
+          raise ArgumentError, "You must specify either the :eval or :sql options for caches_value in #{self.name}"
+        end
+      
+        if reflection.options[:sql] && reflection.options[:eval]
+          raise ArgumentError, ":eval and :sql are mutually exclusive options.  You may specify one or the other for caches_value in #{self.name}"
+        end
+      end
+    
+      def create_cached_value_reflection(name, options)
+        options.assert_valid_keys(:sql, :eval, :cache, :clear, :load, :reload)
+        
+        reflection = ActiveRecord::Reflection::MacroReflection.new(:cached_value, name, options, self)
+        write_inheritable_hash :reflections, name => reflection
+        reflection
+      end
+
+      def cached_value_accessor_method(reflection, association_proxy_class)
+        define_method(reflection.name) do |*params|
+          force_reload = params.first unless params.empty?
+          association = instance_variable_get("@#{reflection.name}")
+          
+          if association.nil? || force_reload
+            association = association_proxy_class.new(self, reflection)
+            instance_variable_set("@#{reflection.name}", association)
+            force_reload ? association.reload : association.load
+          end
+          association.target.nil? ? nil : association
+        end
+      end
+      
+      def cached_value_callback_methods(reflection)
+        %w{clear reload}.each do |operation|
+          if events = reflection.options[operation.to_sym]
+            events = [events] unless events.is_a?(Array)
+            events.map! { |event| event.to_s }
+            ActiveRecord::Callbacks::CALLBACKS.each do |callback|
+              if events.include?(callback)
+                send(callback, Proc.new {|record| record.send(reflection.name).send(operation)})
+              end
+            end
+          end
+        end
+      end
+  end
+end

data/lib/cached_values.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+require File.expand_path(File.dirname(__FILE__) + "/cached_values/cached_value")
+require File.expand_path(File.dirname(__FILE__) + "/cached_values/caches_value")
+
+module CachedValues # :nodoc:
+  VERSION = '1.0.0'
+end
+
+ActiveRecord::Base.send :include, CachesValues

data/tasks/cached_values_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :cached_values do
+#   # Task goes here
+# end

data/test/database.yml

@@ -0,0 +1,18 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: plugin.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: ":memory:"
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: plugin_test
+  :min_messages: ERROR
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: plugin_test

data/test/leprechaun.rb

@@ -0,0 +1,17 @@
+class Leprechaun < ActiveRecord::Base
+  caches_value :favorite_color_in_rot_13, :eval => Proc.new {|leprechaun| leprechaun.favorite_color.tr "A-Za-z", "N-ZA-Mn-za-m" }
+  caches_value :favorite_color_turned_uppercase, :eval => "favorite_color.upcase"
+  caches_value :number_of_gold_coins, :eval => :calculate_gold
+  caches_value :id_of_first_leprechaun_with_same_favorite_color, :sql => 'select id from leprechauns where leprechauns.favorite_color = "#{favorite_color}" and leprechauns.id <> #{id} limit 1'
+  caches_value :favorite_color_in_rot_13_without_cache, :eval => Proc.new {|leprechaun| leprechaun.favorite_color.tr "A-Za-z", "N-ZA-Mn-za-m" }, :cache => false
+  caches_value :favorite_color_turned_uppercase_with_explicit_cache, :eval => "favorite_color.upcase", :cache => 'some_other_cache_field'
+  caches_value :reload_callback, :eval => "rand(1000)", :reload => [:before_save, :after_validation]
+  caches_value :clear_callback, :eval => "rand(1000)", :clear => :before_validation
+  caches_value :float_cast, :sql => "select 82343.222"
+  caches_value :integer_cast, :sql => "select 19"
+  caches_value :string_cast, :sql => 'select "Top \'o the mornin\' to ya"'
+  
+  def calculate_gold
+    '127 gold coins'
+  end
+end

data/test/schema.rb

@@ -0,0 +1,22 @@
+
+require File.expand_path(File.dirname(__FILE__) + "/leprechaun")
+
+ActiveRecord::Schema.define(:version => 1) do
+  
+  create_table :leprechauns do |t|
+    t.column :name,                                             :string
+    t.column :favorite_color,                                   :string
+    t.column :favorite_color_in_rot_13,                         :string
+    t.column :favorite_color_in_rot_13_without_cache,           :string
+    t.column :favorite_color_turned_uppercase,                  :string
+    t.column :id_of_first_leprechaun_with_same_favorite_color,  :integer
+    t.column :some_other_cache_field,                           :string
+    t.column :reload_callback,                                  :float
+    t.column :clear_callback,                                   :float
+  end
+  
+  Leprechaun.create!(:name => 'Mc Nairn', :favorite_color => 'blue')
+  Leprechaun.create!(:name => "O' Houhlihan", :favorite_color => 'ochre')
+  Leprechaun.create!(:name => "Danger Cáinte", :favorite_color => 'blue')
+  
+end

data/test/test_cached_values.rb

@@ -0,0 +1,118 @@
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class CachedValuesTest < Test::Unit::TestCase
+  
+  def setup
+    @mc_nairn = Leprechaun.find(:first)
+    @mc_nairn.favorite_color_in_rot_13.clear
+    @mc_nairn.favorite_color_turned_uppercase.clear
+    @mc_nairn.id_of_first_leprechaun_with_same_favorite_color.clear
+    @mc_nairn.favorite_color_in_rot_13_without_cache.clear
+    @mc_nairn.favorite_color_turned_uppercase_with_explicit_cache.clear
+    @mc_nairn.favorite_color = 'blue'
+    @mc_nairn.save!
+  end
+  
+  def test_proc_should_properly_calculate_value
+    assert_equal 'blue', @mc_nairn.favorite_color
+    assert_equal 'oyhr', @mc_nairn.favorite_color.tr("A-Za-z", "N-ZA-Mn-za-m")
+    assert_equal 'oyhr', @mc_nairn.favorite_color_in_rot_13
+  end
+  
+  def test_string_should_properly_calculate_value
+    assert_equal 'blue', @mc_nairn.favorite_color
+    assert_equal 'BLUE', @mc_nairn.favorite_color_turned_uppercase
+    @mc_nairn.update_attribute(:favorite_color, 'gold')
+    assert_equal 'BLUE', @mc_nairn.favorite_color_turned_uppercase
+    assert_equal 'GOLD', @mc_nairn.favorite_color_turned_uppercase.reload
+  end
+  
+  def test_symbol_should_calculate_value_from_method_call
+    assert_equal '127 gold coins', @mc_nairn.number_of_gold_coins
+    assert_equal '127 gold coins', @mc_nairn.calculate_gold
+    @mc_nairn.class.class_eval { def calculate_gold; '255 gold coins'; end }
+    assert_equal '255 gold coins', @mc_nairn.calculate_gold
+    assert_equal '127 gold coins', @mc_nairn.number_of_gold_coins
+    assert_equal '255 gold coins', @mc_nairn.number_of_gold_coins.reload
+  end
+  
+  def test_sql_should_properly_calculate_value
+    assert_equal 3, @mc_nairn.id_of_first_leprechaun_with_same_favorite_color
+    Leprechaun.find_by_name("O' Houhlihan").update_attribute(:favorite_color, 'blue')
+    assert_equal 3, @mc_nairn.id_of_first_leprechaun_with_same_favorite_color
+    assert_equal 2, @mc_nairn.id_of_first_leprechaun_with_same_favorite_color.reload
+  end
+  
+  def test_should_cache_value
+    assert_equal 'blue', @mc_nairn.favorite_color
+    assert_equal 'oyhr', @mc_nairn.favorite_color_in_rot_13
+    @mc_nairn.update_attribute(:favorite_color, 'red')
+    assert_equal 'erq', @mc_nairn.favorite_color.tr("A-Za-z", "N-ZA-Mn-za-m")
+    assert_equal 'oyhr', @mc_nairn.favorite_color_in_rot_13
+  end
+
+  def test_cache_should_be_invalidated_on_clear
+    assert_equal 'blue', @mc_nairn.favorite_color
+    assert_equal 'oyhr', @mc_nairn.favorite_color_in_rot_13
+    @mc_nairn.favorite_color_in_rot_13.clear
+    assert_nil @mc_nairn.send(:read_attribute, :favorite_color_in_rot_13)
+  end
+  
+  def test_value_should_be_updated_after_its_cleared
+    assert_equal 'blue', @mc_nairn.favorite_color
+    assert_equal 'oyhr', @mc_nairn.favorite_color_in_rot_13
+    @mc_nairn.update_attribute(:favorite_color, 'red')
+    assert_equal 'oyhr', @mc_nairn.favorite_color_in_rot_13
+    @mc_nairn.favorite_color_in_rot_13.clear    
+    assert_equal 'erq', @mc_nairn.favorite_color_in_rot_13
+  end
+  
+  def test_should_not_cache_explicitly_noncaching_values
+    assert_equal 'blue', @mc_nairn.favorite_color
+    assert_equal 'oyhr', @mc_nairn.favorite_color_in_rot_13_without_cache
+    assert_nil @mc_nairn.send(:read_attribute, :favorite_color_in_rot_13_without_cache)
+    @mc_nairn.update_attribute(:favorite_color, 'red')
+    assert_equal 'erq', @mc_nairn.favorite_color.tr("A-Za-z", "N-ZA-Mn-za-m")
+    assert_equal 'erq', @mc_nairn.favorite_color_in_rot_13_without_cache.reload
+    assert_nil @mc_nairn.send(:read_attribute, :favorite_color_in_rot_13_without_cache)
+  end
+  
+  def test_should_respect_explicit_cache_column
+    assert_equal 'BLUE', @mc_nairn.favorite_color_turned_uppercase_with_explicit_cache
+    assert_equal 'BLUE', @mc_nairn.send(:read_attribute, :some_other_cache_field)
+    @mc_nairn.update_attribute(:favorite_color, 'red')
+    assert_equal 'BLUE', @mc_nairn.send(:read_attribute, :some_other_cache_field)
+    assert_equal 'RED', @mc_nairn.favorite_color_turned_uppercase_with_explicit_cache.reload
+  end
+  
+  def test_reload_callback_should_fire
+    value = @mc_nairn.reload_callback.to_s
+    assert_equal value.to_i, @mc_nairn.reload_callback
+    @mc_nairn.save!
+    assert_not_equal value.to_i, @mc_nairn.reload_callback.reload
+    value = @mc_nairn.reload_callback.to_s
+    assert_equal value.to_i, @mc_nairn.reload_callback
+    @mc_nairn.valid?
+    assert_not_equal value.to_i, @mc_nairn.reload_callback
+  end
+  
+  def test_clear_callback_should_fire
+    assert @mc_nairn.clear_callback
+    assert @mc_nairn.instance_variable_get("@clear_callback")
+    @mc_nairn.valid?
+    assert_nil @mc_nairn.instance_variable_get("@clear_callback")
+  end
+  
+  def test_sql_should_cast_to_integer
+    assert @mc_nairn.integer_cast.is_a?(Fixnum)
+  end
+  
+  def test_sql_should_cast_to_string
+    assert @mc_nairn.string_cast.is_a?(String)
+  end
+  
+  def test_sql_should_cast_to_float
+    assert @mc_nairn.float_cast.is_a?(Float)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,36 @@
+# Include this file in your test by copying the following line to your test:
+#   require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'test/unit'
+require 'active_record'
+require 'active_record/fixtures'
+require "cached_values"
+require File.expand_path(File.dirname(__FILE__) + "/leprechaun")
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3'])
+
+load(File.dirname(__FILE__) + "/schema.rb") if File.exist?(File.dirname(__FILE__) + "/schema.rb")
+
+class Test::Unit::TestCase #:nodoc:
+  
+  # def create_fixtures(*table_names)
+  #   if block_given?
+  #     Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
+  #   else
+  #     Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
+  #   end
+  # end
+
+  # Turn off transactional fixtures if you're working with MyISAM tables in MySQL
+  self.use_transactional_fixtures = true
+  
+  # Instantiated fixtures are slow, but give you @david where you otherwise would need people(:david)
+  self.use_instantiated_fixtures  = false
+
+  # Add more helper methods to be used by all tests here...
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: cached_values
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Jack Danger Canty
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-03-07 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.1
+    version: 
+description: ""
+email: 
+- rubygems_cached_values@6brand.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- MIT-LICENSE
+- Manifest.txt
+- README.txt
+- Rakefile
+- init.rb
+- install.rb
+- lib/cached_values.rb
+- lib/cached_values/cached_value.rb
+- lib/cached_values/caches_value.rb
+- tasks/cached_values_tasks.rake
+- test/database.yml
+- test/leprechaun.rb
+- test/schema.rb
+- test/test_cached_values.rb
+- test/test_helper.rb
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/JackDanger/cached_values/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: cachedvalues
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: ""
+test_files: 
+- test/test_cached_values.rb
+- test/test_helper.rb