vendor/rails/activesupport/lib/active_support/memoizable.rb

   1 module ActiveSupport
   2   module Memoizable
   3     def self.memoized_ivar_for(symbol)
   4       "@_memoized_#{symbol.to_s.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')}".to_sym
   5     end
   6
   7     module InstanceMethods
   8       def self.included(base)
   9         base.class_eval do
  10           unless base.method_defined?(:freeze_without_memoizable)
  11             alias_method_chain :freeze, :memoizable
  12           end
  13         end
  14       end
  15
  16       def freeze_with_memoizable
  17         memoize_all unless frozen?
  18         freeze_without_memoizable
  19       end
  20
  21       def memoize_all
  22         prime_cache ".*"
  23       end
  24
  25       def unmemoize_all
  26         flush_cache ".*"
  27       end
  28
  29       def prime_cache(*syms)
  30         syms.each do |sym|
  31           methods.each do |m|
  32             if m.to_s =~ /^_unmemoized_(#{sym})/
  33               if method(m).arity == 0
  34                 __send__($1)
  35               else
  36                 ivar = ActiveSupport::Memoizable.memoized_ivar_for($1)
  37                 instance_variable_set(ivar, {})
  38               end
  39             end
  40           end
  41         end
  42       end
  43
  44       def flush_cache(*syms, &block)
  45         syms.each do |sym|
  46           methods.each do |m|
  47             if m.to_s =~ /^_unmemoized_(#{sym})/
  48               ivar = ActiveSupport::Memoizable.memoized_ivar_for($1)
  49               instance_variable_get(ivar).clear if instance_variable_defined?(ivar)
  50             end
  51           end
  52         end
  53       end
  54     end
  55
  56     def memoize(*symbols)
  57       symbols.each do |symbol|
  58         original_method = :"_unmemoized_#{symbol}"
  59         memoized_ivar = ActiveSupport::Memoizable.memoized_ivar_for(symbol)
  60
  61         class_eval <<-EOS, __FILE__, __LINE__
  62           include InstanceMethods                                                  # include InstanceMethods
  63                                                                                    #
  64           if method_defined?(:#{original_method})                                  # if method_defined?(:_unmemoized_mime_type)
  65             raise "Already memoized #{symbol}"                                     #   raise "Already memoized mime_type"
  66           end                                                                      # end
  67           alias #{original_method} #{symbol}                                       # alias _unmemoized_mime_type mime_type
  68                                                                                    #
  69           if instance_method(:#{symbol}).arity == 0                                # if instance_method(:mime_type).arity == 0
  70             def #{symbol}(reload = false)                                          #   def mime_type(reload = false)
  71               if reload || !defined?(#{memoized_ivar}) || #{memoized_ivar}.empty?  #     if reload || !defined?(@_memoized_mime_type) || @_memoized_mime_type.empty?
  72                 #{memoized_ivar} = [#{original_method}.freeze]                     #       @_memoized_mime_type = [_unmemoized_mime_type.freeze]
  73               end                                                                  #     end
  74               #{memoized_ivar}[0]                                                  #     @_memoized_mime_type[0]
  75             end                                                                    #   end
  76           else                                                                     # else
  77             def #{symbol}(*args)                                                   #   def mime_type(*args)
  78               #{memoized_ivar} ||= {} unless frozen?                               #     @_memoized_mime_type ||= {} unless frozen?
  79               reload = args.pop if args.last == true || args.last == :reload       #     reload = args.pop if args.last == true || args.last == :reload
  80                                                                                    #
  81               if defined?(#{memoized_ivar}) && #{memoized_ivar}                    #     if defined?(@_memoized_mime_type) && @_memoized_mime_type
  82                 if !reload && #{memoized_ivar}.has_key?(args)                      #       if !reload && @_memoized_mime_type.has_key?(args)
  83                   #{memoized_ivar}[args]                                           #         @_memoized_mime_type[args]
  84                 elsif #{memoized_ivar}                                             #       elsif @_memoized_mime_type
  85                   #{memoized_ivar}[args] = #{original_method}(*args).freeze        #         @_memoized_mime_type[args] = _unmemoized_mime_type(*args).freeze
  86                 end                                                                #       end
  87               else                                                                 #     else
  88                 #{original_method}(*args)                                          #       _unmemoized_mime_type(*args)
  89               end                                                                  #     end
  90             end                                                                    #   end
  91           end                                                                      # end
  92                                                                                    #
  93           if private_method_defined?(#{original_method.inspect})                   # if private_method_defined?(:_unmemoized_mime_type)
  94             private #{symbol.inspect}                                              #   private :mime_type
  95           end                                                                      # end
  96         EOS
  97       end
  98     end
  99   end
 100 end