method

memoize

v3.0.9 - Show latest stable - 4 notes - Class: ActiveSupport::Memoizable

1.0.0
1.1.1
1.1.6
1.2.0
1.2.6
2.0.0
2.0.3
2.1.0
2.2.1
2.3.2 (0)
2.3.8 (0)
3.0.0 (0)
3.0.5 (0)
3.0.9 (0)
3.1.0 (0)
3.2.1 (0)
3.2.3 (0)
3.2.8 (0)
3.2.13 (0)
4.0.2
4.1.8
4.2.1
4.2.7
What's this?

memoize(*symbols) public

No documentation

This method has no description. You can help the Ruby on Rails community by adding new notes.

# File activesupport/lib/active_support/memoizable.rb, line 59
    def memoize(*symbols)
      symbols.each do |symbol|
        original_method = :"_unmemoized_#{symbol}"
        memoized_ivar = ActiveSupport::Memoizable.memoized_ivar_for(symbol)

        class_eval           include InstanceMethods                                                  # include InstanceMethods                                                                                   #          if method_defined?(:#{original_method})                                  # if method_defined?(:_unmemoized_mime_type)            raise "Already memoized #{symbol}"                                     #   raise "Already memoized mime_type"          end                                                                      # end          alias #{original_method} #{symbol}                                       # alias _unmemoized_mime_type mime_type                                                                                   #          if instance_method(:#{symbol}).arity == 0                                # if instance_method(:mime_type).arity == 0            def #{symbol}(reload = false)                                          #   def mime_type(reload = false)              if reload || !defined?(#{memoized_ivar}) || #{memoized_ivar}.empty?  #     if reload || !defined?(@_memoized_mime_type) || @_memoized_mime_type.empty?                #{memoized_ivar} = [#{original_method}]                            #       @_memoized_mime_type = [_unmemoized_mime_type]              end                                                                  #     end              #{memoized_ivar}[0]                                                  #     @_memoized_mime_type[0]            end                                                                    #   end          else                                                                     # else            def #{symbol}(*args)                                                   #   def mime_type(*args)              #{memoized_ivar} ||= {} unless frozen?                               #     @_memoized_mime_type ||= {} unless frozen?              reload = args.pop if args.last == true || args.last == :reload       #     reload = args.pop if args.last == true || args.last == :reload                                                                                   #              if defined?(#{memoized_ivar}) && #{memoized_ivar}                    #     if defined?(@_memoized_mime_type) && @_memoized_mime_type                if !reload && #{memoized_ivar}.has_key?(args)                      #       if !reload && @_memoized_mime_type.has_key?(args)                  #{memoized_ivar}[args]                                           #         @_memoized_mime_type[args]                elsif #{memoized_ivar}                                             #       elsif @_memoized_mime_type                  #{memoized_ivar}[args] = #{original_method}(*args)               #         @_memoized_mime_type[args] = _unmemoized_mime_type(*args)                end                                                                #       end              else                                                                 #     else                #{original_method}(*args)                                          #       _unmemoized_mime_type(*args)              end                                                                  #     end            end                                                                    #   end          end                                                                      # end                                                                                   #          if private_method_defined?(#{original_method.inspect})                   # if private_method_defined?(:_unmemoized_mime_type)            private #{symbol.inspect}                                              #   private :mime_type          elsif protected_method_defined?(#{original_method.inspect})              # elsif protected_method_defined?(:_unmemoized_mime_type)            protected #{symbol.inspect}                                            #   protected :mime_type          end                                                                      # end, __FILE__, __LINE__ + 1
      end
    end

December 12, 2011

2 thanks

Need to extend class when using this

I had to dig around to find this out - if you want to use memoize somewhere, like an ActiveRecord model, you need to add

extend ActiveSupport::Memoizable

to the class. This doesn’t seem to be explained anywhere (the only docs are 3 year old blog posts anyway).

April 27, 2012 - (>= v3.2.1)

1 thank

Example from Code School

module Tweets

 class ShowPresenter
   extend ActiveSupport::Memoizable

   def initialize(tweet)
     @tweet = tweet
   end

   def username
     @tweet.user.username
   end

   def status
     @tweet.status
   end

   def favorites_count
     @tweet.favorites.count
   end

   memoize :username, :status, :favorites_count

 end
end

From http://railsbest.com/

July 9, 2012

0 thanks

this has been deprecated; replace with Memoist

In Rails 3.2, memoize has been deprecated. In edge Rails, it has been removed.

The commit when it was deprecated: http://github.com/rails/rails/commit/36253916b0b788d6ded56669d37c96ed05c92c5c

A Stack Overflow question about this change: http://stackoverflow.com/q/9132197/578288

I personally disagree with the removal of memoize, and don’t recommend using the `||=` pattern Rails now suggests. The exception is if your entire program only memoizes something once or twice, so it’s not worth including a gem for.

The easiest way to keep using memoize is to use the Memoist gem (http://github.com/matthewrudy/memoist , http://rubygems.org/gems/memoist), which is a simple extraction of ActiveSupport::Memoizable into its own gem.

November 10, 2015

0 thanks

instead of memoize

See this for deprecated github.com/rails/rails/commit/36253916b0b788d6ded56669d37c96ed05c92c5c

use

def something
  return @_var if defined? @_var
  # more code
end