memonymous 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+spikes/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.2-p180@memonymous --create --install

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in memonymous.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,13 @@
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 
+                   Version 2, December 2004 
+
+Copyright (C) 2004 Sam Hocevar <sam@hocevar.net> 
+
+Everyone is permitted to copy and distribute verbatim or modified 
+copies of this license document, and changing it is allowed as long 
+as the name is changed. 
+
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE 
+  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 
+
+ 0. You just DO WHAT THE FUCK YOU WANT TO.

data/README.md

@@ -0,0 +1,51 @@
+# Memonymous:  a Ruby memoization module that doesn't clutter up its includees.
+
+## License
+
+Public domain (more or less).  See the LICENSE file for more information.
+
+## Origin
+
+Inspired by a recent Hangman puzzle at the Portland Ruby Brigade ([link](http://groups.google.com/group/pdxruby/browse_thread/thread/19d58126a268e89a/078efefc26ddcf7b)), I decided to try writing a memoization module that used `super` instead of mucking around with `alias_method_chain`.
+
+Unfortunately, the only way I could think of to get this to work was to override the including class's .new method, so that all new instances were actually instances of a newly-created subclass...and that just seemed like a Really Bad Idea™.
+
+Fortunately, I did find an interesting workaround, and in the process learned a few new tricks that have been sitting right there in the Kernel and Module classes just waiting for me to notice them.
+
+## Usage:
+
+<pre>
+  class FrankSinatra
+    attr_reader :call_count
+    def dont_be_afraid_you_can_call_me
+      @call_count ||= 0
+      @call_count += 1
+    end
+  end
+
+  class MemoizedFrankSinatra < FrankSinatra
+    include Memonymous
+    memoize :dont_be_afraid_you_can_call_me
+  end
+
+  naked_frank = FrankSinatra.new
+  3.times do
+    naked_frank.dont_be_afraid_you_can_call_me
+  end
+  p naked_frank.call_count # => 3
+
+  memoized_frank = MemoizedFrankSinatra.new
+  3.times do
+    memoized_frank.dont_be_afraid_you_can_call_me
+  end
+  p memoized_frank.call_count # => 1
+</pre>
+
+## Technique
+
+I was actually quite amused by this one.  Because Ruby doesn't let you change the superclass of a Class object, I couldn't insert new methods above the includee in the hierarchy.  Instead, when .memoize is called, it asks Ruby for an UnboundMethod object for each method it's supposed to memoize and hangs onto it in a class instance variable.  Then it defines its own replacement for the same method.
+
+Later, when you call the memoized method, we either look to see if we've already computed it (thus the 'memoization' part of the gem), or we grab the UnboundMethod, bind it to the caller, call it, and save the result.  This process reminds me of the Wallace and Gromit film "The Wrong Trousers" -- see the comments in the Memonymous module for a link to a Google video search.
+
+Thanks also to Jay Fields for the technique -- I had started down this path and was trying to figure it out, but came across a [2008 blog post](http://blog.jayfields.com/2008/04/alternatives-for-redefining-methods.html) with a conveniently-packaged code snippet.
+

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/memonymous.rb

@@ -0,0 +1,41 @@
+require "memonymous/version"
+
+module Memonymous
+  def self.included(receiver)
+    receiver.extend ClassMethod
+    unless receiver.instance_variable_defined?('@memoized_methods')
+      receiver.instance_variable_set('@memoized_methods', {})
+    end
+  end
+
+  # Note the singular name!
+  # The point of this exercise is to memoize without cluttering up the function namespace.
+  module ClassMethod
+    def memoize(*methods)
+      Array(methods).flatten.map(&:to_sym).each do |mname|
+        @memoized_methods[mname] = instance_method(mname) # save the UnboundMethod for later
+        class_eval <<-RUBY
+          # apparently 'def' is faster than 'define_method', according to Several Random People on the Internet
+          def #{mname}(*args, &b)
+            ivar_name = '@#{mname}'
+
+            # The entire point:  returning fast if we already know the answer
+            return instance_variable_get(ivar_name) if instance_variable_defined?(ivar_name)
+
+            # FIRST POST^H^H^H^H CALL!
+            # Grab the UnboundMethod, bind it, and call it.
+            # I like to think of this as the "Gromit's Train Track" approach to memoization.
+            # (See: http://www.google.com/search?q=wallace+and+gromit+train+chase if you don't get the reference.)
+            return instance_variable_set( ivar_name,
+                                          self \
+                                            .class \
+                                            .instance_variable_get('@memoized_methods')[:'#{mname}'] \
+                                            .bind(self) \
+                                            .call(*args, &b)
+                                        )
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/memonymous/version.rb

@@ -0,0 +1,3 @@
+module Memonymous
+  VERSION = "0.1.0"
+end

data/memonymous.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "memonymous/version"
+
+Gem::Specification.new do |s|
+  s.name        = "memonymous"
+  s.version     = Memonymous::VERSION
+  s.authors     = ["Sam Livingston-Gray"]
+  s.email       = ["geeksam@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Yet another memoizing gem.  This one doesn't pollute your method namespace.}
+  s.description = %q{VERY SIMPLISTIC memoization for functions (one memoized value per function; no regard for arguments). Uses UnboundMethods instead of method aliasing, so you don't see extra method names when you inspect your object.}
+
+  s.rubyforge_project = "memonymous"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/memonymous_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[test_helper]))
+
+describe Memonymous do
+  before do
+    @memoize_this = Class.new do
+      attr_reader :call_count
+      def dont_be_afraid_you_can_call_me
+        @call_count ||= 0
+        @call_count += 1
+      end
+    end
+  end
+
+  it 'should add a .memoize method' do
+    refute @memoize_this.respond_to?(:memoize), "Method found before it should be there"
+    @memoize_this.send(:include, Memonymous)
+    assert @memoize_this.respond_to?(:memoize), "Method not found after it should've been added"
+  end
+  
+  it 'should ONLY add a .memoize method' do
+    old_klass_methods = @memoize_this.methods.sort.dup
+    old_inst_methods  = @memoize_this.instance_methods.sort.dup
+    
+    @memoize_this.send(:include, Memonymous)
+
+    new_klass_methods = @memoize_this.methods.sort.dup
+    new_inst_methods  = @memoize_this.instance_methods.sort.dup
+
+    assert_equal [:memoize], new_klass_methods - old_klass_methods
+    assert_equal [],         new_inst_methods  - old_inst_methods
+  end
+
+  describe 'when included into a class' do
+    before :each do
+      @memoize_this.send(:include, Memonymous)
+    end
+    
+    it "should not memoize methods it hasn't been told about" do
+      foo = @memoize_this.new
+      foo.dont_be_afraid_you_can_call_me
+      foo.dont_be_afraid_you_can_call_me
+      assert_equal 2, foo.call_count
+    end
+
+    it 'should set up a @memoized_methods class instance variable' do
+      assert @memoize_this.instance_variables.map(&:to_sym).include?(:'@memoized_methods')
+    end
+
+    it 'should memoize methods it has been told about' do
+      @memoize_this.memoize(:dont_be_afraid_you_can_call_me)
+      foo = @memoize_this.new
+      foo.dont_be_afraid_you_can_call_me
+      foo.dont_be_afraid_you_can_call_me
+      assert_equal 1, foo.call_count
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'bundler/setup'
+Bundler.setup(:default, :development)
+require 'test/unit'
+require 'minitest/spec'
+require 'memonymous'

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: memonymous
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Sam Livingston-Gray
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-27 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: VERY SIMPLISTIC memoization for functions (one memoized value per function; no regard for arguments). Uses UnboundMethods instead of method aliasing, so you don't see extra method names when you inspect your object.
+email: 
+- geeksam@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/memonymous.rb
+- lib/memonymous/version.rb
+- memonymous.gemspec
+- test/memonymous_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: memonymous
+rubygems_version: 1.6.0
+signing_key: 
+specification_version: 3
+summary: Yet another memoizing gem.  This one doesn't pollute your method namespace.
+test_files: 
+- test/memonymous_test.rb
+- test/test_helper.rb