arid_cache 1.1.1 → 1.2.0

data/README.rdoc

@@ -8,6 +8,7 @@ AridCache simplifies caching by supporting auto-expiring cache keys - as well as
 
 == Changes
 
+v1.2.0: Fix Rails 3 ActiveRecord hooks & remove some Rails dependencies
 v1.0.5: Support <tt>:raw</tt> and <tt>:clear</tt> options.
 
 == Install
@@ -22,10 +23,6 @@ Then
 
   bundle install
 
-For some reason AridCache is not being included into ActiveRecord, so add the following to an initializer to get around that until I fix it:
-
-  AridCache.init_rails
-
 <b>Rails 2:</b>
 
 Add the gem to your <tt>config/environment.rb</tt> file:
@@ -353,16 +350,12 @@ In some circumstances - like when you are querying on a named scope - if you hav
 == Compatibility
 
 Tested on Ruby 1.8.6, 1.8.7, REE 1.8.7 and 1.9.1.
-Tested in Rails 2.3.* and Rails 3
+Tested in Rails 2.3.11, Rails 3.0.0, Rails 3.0.5
 
 For Ruby < 1.8.7 you probably want to include the following to extend the Array class with a <tt>count</tt> method.  Otherwise your <tt>cached_<key>_count</tt> calls probably won't work:
 
   Array.class_eval { alias count size }
 
-For Rails 3 for some reason AridCache is not being included into ActiveRecord, so add the following to an initializer to get around that:
-
-  AridCache.init_rails
-
 == Resources & Metrics
 
 

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.2.0

data/arid_cache.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{arid_cache}
-  s.version = "1.1.1"
+  s.version = "1.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Karl Varga"]
-  s.date = %q{2011-03-21}
+  s.date = %q{2011-03-28}
   s.description = %q{AridCache makes caching easy and effective.  AridCache supports caching on all your model named scopes, class methods and instance methods right out of the box.  AridCache prevents caching logic from cluttering your models and clarifies your logic by making explicit calls to cached result sets.
 AridCache is designed for handling large, expensive ActiveRecord collections but is equally useful for caching anything else as well.
 }
@@ -31,6 +31,9 @@ AridCache is designed for handling large, expensive ActiveRecord collections but
      "lib/arid_cache/active_record.rb",
      "lib/arid_cache/cache_proxy.rb",
      "lib/arid_cache/helpers.rb",
+     "lib/arid_cache/inflector.rb",
+     "lib/arid_cache/inflector/inflections.rb",
+     "lib/arid_cache/railtie.rb",
      "lib/arid_cache/store.rb",
      "rails/init.rb",
      "spec/arid_cache/active_record_spec.rb",

data/init.rb

@@ -3,4 +3,4 @@ begin
 rescue LoadError
   require 'arid_cache' # From gem
 end
-AridCache.init_rails
+AridCache.init_rails if defined?(Rails)

data/lib/arid_cache.rb

@@ -5,6 +5,8 @@ require 'arid_cache/helpers'
 require 'arid_cache/store'
 require 'arid_cache/active_record'
 require 'arid_cache/cache_proxy'
+require 'arid_cache/railtie' if defined?(Rails)
+require 'arid_cache/inflector'
 
 module AridCache
   extend AridCache::Helpers

data/lib/arid_cache/active_record.rb

@@ -36,7 +36,7 @@ module AridCache
         elsif options[:auto_expire]
           self.cache_key
         else
-          "#{self.class.name.downcase.pluralize}/#{self.id}"
+          "#{AridCache::Inflector.pluralize(self.class.name.downcase)}/#{self.id}"
         end
         'arid-cache-' + object_key + '-' + key.to_s
       end

data/lib/arid_cache/cache_proxy.rb

@@ -39,7 +39,7 @@ module AridCache
     end
 
     def self.clear_instance_caches(object)
-      key = (object.is_a?(Class) ? object : object.class).name.pluralize.downcase
+      key = AridCache::Inflector.pluralize((object.is_a?(Class) ? object : object.class).name).downcase
       Rails.cache.delete_matched(%r[arid-cache-#{key}.*])
     end
 

data/lib/arid_cache/inflector.rb

@@ -0,0 +1,58 @@
+require 'arid_cache/inflector/inflections'
+
+module AridCache
+  AridCache::Inflector.inflections do |inflect|
+    inflect.plural(/$/, 's')
+    inflect.plural(/s$/i, 's')
+    inflect.plural(/(ax|test)is$/i, '\1es')
+    inflect.plural(/(octop|vir)us$/i, '\1i')
+    inflect.plural(/(alias|status)$/i, '\1es')
+    inflect.plural(/(bu)s$/i, '\1ses')
+    inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+    inflect.plural(/([ti])um$/i, '\1a')
+    inflect.plural(/sis$/i, 'ses')
+    inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    inflect.plural(/(hive)$/i, '\1s')
+    inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+    inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+    inflect.plural(/([m|l])ouse$/i, '\1ice')
+    inflect.plural(/^(ox)$/i, '\1en')
+    inflect.plural(/(quiz)$/i, '\1zes')
+
+    inflect.singular(/s$/i, '')
+    inflect.singular(/(n)ews$/i, '\1ews')
+    inflect.singular(/([ti])a$/i, '\1um')
+    inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
+    inflect.singular(/(^analy)ses$/i, '\1sis')
+    inflect.singular(/([^f])ves$/i, '\1fe')
+    inflect.singular(/(hive)s$/i, '\1')
+    inflect.singular(/(tive)s$/i, '\1')
+    inflect.singular(/([lr])ves$/i, '\1f')
+    inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    inflect.singular(/(s)eries$/i, '\1eries')
+    inflect.singular(/(m)ovies$/i, '\1ovie')
+    inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+    inflect.singular(/([m|l])ice$/i, '\1ouse')
+    inflect.singular(/(bus)es$/i, '\1')
+    inflect.singular(/(o)es$/i, '\1')
+    inflect.singular(/(shoe)s$/i, '\1')
+    inflect.singular(/(cris|ax|test)es$/i, '\1is')
+    inflect.singular(/(octop|vir)i$/i, '\1us')
+    inflect.singular(/(alias|status)es$/i, '\1')
+    inflect.singular(/^(ox)en/i, '\1')
+    inflect.singular(/(vert|ind)ices$/i, '\1ex')
+    inflect.singular(/(matr)ices$/i, '\1ix')
+    inflect.singular(/(quiz)zes$/i, '\1')
+    inflect.singular(/(database)s$/i, '\1')
+
+    inflect.irregular('person', 'people')
+    inflect.irregular('man', 'men')
+    inflect.irregular('child', 'children')
+    inflect.irregular('sex', 'sexes')
+    inflect.irregular('move', 'moves')
+    inflect.irregular('cow', 'kine')
+
+    inflect.uncountable(%w(equipment information rice money species series fish sheep jeans))
+  end
+end

data/lib/arid_cache/inflector/inflections.rb

@@ -0,0 +1,213 @@
+module AridCache
+  module Inflector
+    extend self
+    
+    # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional
+    # inflection rules. Examples:
+    #
+    #   AridCache::Inflector.inflections do |inflect|
+    #     inflect.plural /^(ox)$/i, '\1\2en'
+    #     inflect.singular /^(ox)en/i, '\1'
+    #
+    #     inflect.irregular 'octopus', 'octopi'
+    #
+    #     inflect.uncountable "equipment"
+    #   end
+    #
+    # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+    # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+    # already have been loaded.
+    class Inflections
+      def self.instance
+        @__instance__ ||= new
+      end
+
+      attr_reader :plurals, :singulars, :uncountables, :humans
+
+      def initialize
+        @plurals, @singulars, @uncountables, @humans = [], [], [], []
+      end
+
+      # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+      # The replacement should always be a string that may include references to the matched data from the rule.
+      def plural(rule, replacement)
+        @uncountables.delete(rule) if rule.is_a?(String)
+        @uncountables.delete(replacement)
+        @plurals.insert(0, [rule, replacement])
+      end
+
+      # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+      # The replacement should always be a string that may include references to the matched data from the rule.
+      def singular(rule, replacement)
+        @uncountables.delete(rule) if rule.is_a?(String)
+        @uncountables.delete(replacement)
+        @singulars.insert(0, [rule, replacement])
+      end
+
+      # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+      # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+      #
+      # Examples:
+      #   irregular 'octopus', 'octopi'
+      #   irregular 'person', 'people'
+      def irregular(singular, plural)
+        @uncountables.delete(singular)
+        @uncountables.delete(plural)
+        if singular[0,1].upcase == plural[0,1].upcase
+          plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+          plural(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + plural[1..-1])
+          singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+        else
+          plural(Regexp.new("#{singular[0,1].upcase}(?i)#{singular[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
+          plural(Regexp.new("#{singular[0,1].downcase}(?i)#{singular[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
+          plural(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
+          plural(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
+          singular(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), singular[0,1].upcase + singular[1..-1])
+          singular(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), singular[0,1].downcase + singular[1..-1])
+        end
+      end
+
+      # Add uncountable words that shouldn't be attempted inflected.
+      #
+      # Examples:
+      #   uncountable "money"
+      #   uncountable "money", "information"
+      #   uncountable %w( money information rice )
+      def uncountable(*words)
+        (@uncountables << words).flatten!
+      end
+
+      # Specifies a humanized form of a string by a regular expression rule or by a string mapping.
+      # When using a regular expression based replacement, the normal humanize formatting is called after the replacement.
+      # When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name')
+      #
+      # Examples:
+      #   human /_cnt$/i, '\1_count'
+      #   human "legacy_col_person_name", "Name"
+      def human(rule, replacement)
+        @humans.insert(0, [rule, replacement])
+      end
+
+      # Clears the loaded inflections within a given scope (default is <tt>:all</tt>).
+      # Give the scope as a symbol of the inflection type, the options are: <tt>:plurals</tt>,
+      # <tt>:singulars</tt>, <tt>:uncountables</tt>, <tt>:humans</tt>.
+      #
+      # Examples:
+      #   clear :all
+      #   clear :plurals
+      def clear(scope = :all)
+        case scope
+          when :all
+            @plurals, @singulars, @uncountables = [], [], []
+          else
+            instance_variable_set "@#{scope}", []
+        end
+      end
+    end
+
+    # Yields a singleton instance of Inflector::Inflections so you can specify additional
+    # inflector rules.
+    #
+    # Example:
+    #   AridCache::Inflector.inflections do |inflect|
+    #     inflect.uncountable "rails"
+    #   end
+    def inflections
+      if block_given?
+        yield Inflections.instance
+      else
+        Inflections.instance
+      end
+    end
+
+    # Returns the plural form of the word in the string.
+    #
+    # Examples:
+    #   "post".pluralize             # => "posts"
+    #   "octopus".pluralize          # => "octopi"
+    #   "sheep".pluralize            # => "sheep"
+    #   "words".pluralize            # => "words"
+    #   "CamelOctopus".pluralize     # => "CamelOctopi"
+    def pluralize(word)
+      result = word.to_s.dup
+
+      if word.empty? || inflections.uncountables.include?(result.downcase)
+        result
+      else
+        inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+        result
+      end
+    end
+
+    # The reverse of +pluralize+, returns the singular form of a word in a string.
+    #
+    # Examples:
+    #   "posts".singularize            # => "post"
+    #   "octopi".singularize           # => "octopus"
+    #   "sheep".singularize            # => "sheep"
+    #   "word".singularize             # => "word"
+    #   "CamelOctopi".singularize      # => "CamelOctopus"
+    def singularize(word)
+      result = word.to_s.dup
+
+      if inflections.uncountables.any? { |inflection| result =~ /#{inflection}\Z/i }
+        result
+      else
+        inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+        result
+      end
+    end
+
+    # Capitalizes the first word and turns underscores into spaces and strips a
+    # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output.
+    #
+    # Examples:
+    #   "employee_salary" # => "Employee salary"
+    #   "author_id"       # => "Author"
+    def humanize(lower_case_and_underscored_word)
+      result = lower_case_and_underscored_word.to_s.dup
+
+      inflections.humans.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+      result.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+    end
+
+    # Capitalizes all the words and replaces some characters in the string to create
+    # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+    # used in the Rails internals.
+    #
+    # +titleize+ is also aliased as as +titlecase+.
+    #
+    # Examples:
+    #   "man from the boondocks".titleize # => "Man From The Boondocks"
+    #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
+    def titleize(word)
+      humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize }
+    end
+
+    # Create the name of a table like Rails does for models to table names. This method
+    # uses the +pluralize+ method on the last word in the string.
+    #
+    # Examples
+    #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
+    #   "egg_and_ham".tableize     # => "egg_and_hams"
+    #   "fancyCategory".tableize   # => "fancy_categories"
+    def tableize(class_name)
+      pluralize(underscore(class_name))
+    end
+
+    # Create a class name from a plural table name like Rails does for table names to models.
+    # Note that this returns a string and not a Class. (To convert to an actual class
+    # follow +classify+ with +constantize+.)
+    #
+    # Examples:
+    #   "egg_and_hams".classify # => "EggAndHam"
+    #   "posts".classify        # => "Post"
+    #
+    # Singular names are not handled correctly:
+    #   "business".classify     # => "Busines"
+    def classify(table_name)
+      # strip out any leading schema name
+      camelize(singularize(table_name.to_s.sub(/.*\./, '')))
+    end
+  end
+end

data/lib/arid_cache/railtie.rb

@@ -0,0 +1,14 @@
+# Rails 3 configuration via Railtie
+
+if defined?(Rails::Railtie)
+  module AridCache
+    class Railtie < Rails::Railtie
+
+      initializer 'arid_cache.init' do
+        ActiveSupport.on_load(:active_record) do
+          include AridCache::ActiveRecord
+        end
+      end
+    end
+  end
+end

data/lib/arid_cache/store.rb

@@ -1,6 +1,6 @@
 module AridCache
   class Store < Hash
-    
+
     # AridCache::Store::Blueprint
     #
     # Stores options and blocks that are used to generate results for finds
@@ -13,40 +13,40 @@ module AridCache
         self.proc = proc
         self.opts = opts
       end
-            
+
       def klass=(object) # store the class name only
         self['klass'] = object.is_a?(Class) ? object.name : object.class.name
       end
-      
+
       def klass
         self['klass'].constantize unless self['klass'].nil?
-      end 
-      
+      end
+
       def opts=(value)
         self['opts'] = value.symbolize_keys! unless !value.respond_to?(:symbolize_keys)
-      end    
-      
+      end
+
       def opts
         self['opts'] || {}
       end
-      
+
       def proc(object=nil)
         if self['proc'].nil? && !object.nil?
           self['proc'] = key
         else
           self['proc']
         end
-      end 
+      end
     end
-    
+
     #
     # Capture cache configurations and blocks and store them in the store.
     #
     # A block is evaluated within the scope of this class.  The blocks
     # contains calls to methods which define the caches and give options
-    # for each cache. 
+    # for each cache.
     #
-    # Don't instantiate directly.  Rather instantiate the Instance- or 
+    # Don't instantiate directly.  Rather instantiate the Instance- or
     # ClassCacheConfiguration.
     Configuration = Struct.new(:klass, :global_opts)  do
 
@@ -54,7 +54,7 @@ module AridCache
         self.global_opts = global_opts
         self.klass = klass
       end
-      
+
       def method_missing(key, *args, &block)
         opts = global_opts.merge(args.empty? ? {} : args.first)
         case self
@@ -67,15 +67,15 @@ module AridCache
     end
     class InstanceCacheConfiguration < Configuration; end #:nodoc:
     class ClassCacheConfiguration    < Configuration; end #:nodoc:
-    
+
     def has?(object, key)
       self.include?(object_store_key(object, key))
     end
-    
+
     # Empty the proc store
     def delete!
       delete_if { true }
-    end 
+    end
 
     def self.instance
       @@singleton_instance ||= self.new
@@ -84,7 +84,7 @@ module AridCache
     def find(object, key)
       self[object_store_key(object, key)]
     end
-    
+
     def add_instance_cache_configuration(klass, key, opts, proc)
       add_generic_cache_configuration(instance_store_key(klass, key), klass, key, opts, proc)
     end
@@ -96,7 +96,7 @@ module AridCache
     def add_object_cache_configuration(object, key, opts, proc)
       add_generic_cache_configuration(object_store_key(object, key), object, key, opts, proc)
     end
-    
+
     def find_or_create(object, key)
       store_key = object_store_key(object, key)
       if self.include?(store_key)
@@ -105,20 +105,20 @@ module AridCache
         self[store_key] = AridCache::Store::Blueprint.new(object, key)
       end
     end
-    
+
     protected
-    
+
     def add_generic_cache_configuration(store_key, *args)
       self[store_key] = AridCache::Store::Blueprint.new(*args)
     end
-      
+
     def initialize
     end
-    
+
     def class_store_key(klass, key);    klass.name.downcase + '-' + key.to_s; end
-    def instance_store_key(klass, key); klass.name.downcase.pluralize + '-' + key.to_s; end
+    def instance_store_key(klass, key); AridCache::Inflector.pluralize(klass.name.downcase) + '-' + key.to_s; end
     def object_store_key(object, key)
       case object; when Class; class_store_key(object, key); else; instance_store_key(object.class, key); end
     end
-  end 
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: arid_cache
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 31
   prerelease: 
   segments: 
   - 1
-  - 1
-  - 1
-  version: 1.1.1
+  - 2
+  - 0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Karl Varga
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-21 00:00:00 -07:00
+date: 2011-03-28 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -99,6 +99,9 @@ files:
 - lib/arid_cache/active_record.rb
 - lib/arid_cache/cache_proxy.rb
 - lib/arid_cache/helpers.rb
+- lib/arid_cache/inflector.rb
+- lib/arid_cache/inflector/inflections.rb
+- lib/arid_cache/railtie.rb
 - lib/arid_cache/store.rb
 - rails/init.rb
 - spec/arid_cache/active_record_spec.rb