simple_memoize 1.0.0 → 1.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jack Danger Canty
+
+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/README.txt

@@ -2,10 +2,13 @@
 
 * http://github.com/JackDanger/simple_memoize/
 
+Developed for and by the engineers at http://adPickles.com/
+
 == DESCRIPTION:
 
 Provides in-memory caching of any Ruby method.  It's dead simple and won't get in the way of any of your code.
 For something more robust that offers persistence try http://github.com/JackDanger/cached_values/
+Documentation also available here: http://objectproxy.rubyforge.org/simple_memoize/
 
 == USAGE:
 
@@ -88,7 +91,7 @@ As a gem:
 
 (The MIT License)
 
-Copyright (c) 2008 FIX
+Copyright (c) 2008 Jack Danger Canty, Joel Friedman
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,12 +1,15 @@
-# -*- ruby -*-
-
-require 'rubygems'
-require 'hoe'
-require './lib/simple_memoize.rb'
-
-Hoe.new('simple_memoize', SimpleMemoize::VERSION) do |p|
-  p.rubyforge_name = 'objectproxy' # if different than lowercase project name
-  p.developer('Jack Danger Canty', 'rubyforge@6brand.com')
-end
-
 # vim: syntax=Ruby
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "simple_memoize"
+    gem.summary = %Q{Very lightweight way to ensure some methods only run once}
+    gem.email = "rubygems@6brand.com"
+    gem.homepage = "http://github.com/JackDanger/simple_memoize"
+    gem.authors = ["Jack Danger Canty"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.1

data/init.rb

@@ -0,0 +1 @@
+require 'simple_memoize'

data/lib/simple_memoize.rb

@@ -1,36 +1,48 @@
 module SimpleMemoize
-  VERSION = '1.0.0'
+  VERSION = '1.1.2'
 
   module Module
     def memoize(*method_names)
       method_names.each do |method_name|
         method_name = method_name.to_s
-        memoized_method_name = "#{method_name}_with_memo"
-        regular_method_name  = "#{method_name}_without_memo"
+        stripped_method_name = method_name.sub(/([!?])$/, '')
 
-        unless (instance_methods + private_instance_methods).include?(method_name)
+        punctuation = $1
+        wordy_punctuation = (punctuation == '!' ? '_bang' : '_huh') if punctuation
+        ivar_name = "@#{stripped_method_name}#{wordy_punctuation}"
+
+        memoized_method_name = "#{stripped_method_name}_with_memo#{punctuation}"
+        regular_method_name  = "#{stripped_method_name}_without_memo#{punctuation}"
+
+        unless __include_method_name__( (instance_methods + private_instance_methods), method_name )
           raise NoMethodError, "The Method '#{method_name}' cannot be memoized because it doesn't exist in #{self}"
         end
         return if self.method_defined?(memoized_method_name)
     
-        self.class_eval do
-
-          define_method memoized_method_name do |*args|
-            @simple_memoize ||= {}
-            @simple_memoize[method_name] ||= {}
-            @simple_memoize[method_name][args] ||= send(regular_method_name, *args)
+        self.class_eval "
+          def #{memoized_method_name}(*args)
+            if defined?(#{ivar_name})
+              #{ivar_name}
+            else
+              #{ivar_name} = #{regular_method_name}(*args)
+            end
           end
 
-          alias_method regular_method_name, method_name
-          alias_method method_name, memoized_method_name
-
-          protected method_name if protected_instance_methods.include?(regular_method_name)
-          private   method_name if private_instance_methods.include?(regular_method_name)
+          alias_method :#{regular_method_name}, :#{method_name}
+          alias_method :#{method_name}, :#{memoized_method_name}
 
-        end
+          protected :#{method_name} if __include_method_name__( protected_instance_methods, '#{regular_method_name}' )
+          private   :#{method_name} if __include_method_name__( private_instance_methods, '#{regular_method_name}' )
+        "
       end
     end
+
+    private
+    # Necessary because ruby1.9 now returns methods as symbols not strings
+    def __include_method_name__(methods, method_name)
+      methods.include?( method_name ) || methods.include?( method_name.to_sym )
+    end
   end
 end
 
-Module.send :include, SimpleMemoize::Module
+Module.send :include, SimpleMemoize::Module

data/rails/init.rb

@@ -0,0 +1 @@
+require 'simple_memoize'

data/simple_memoize.gemspec

@@ -0,0 +1,46 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{simple_memoize}
+  s.version = "1.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jack Danger Canty"]
+  s.date = %q{2011-04-10}
+  s.email = %q{rubygems@6brand.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.txt"
+  ]
+  s.files = [
+    "LICENSE",
+    "README.txt",
+    "Rakefile",
+    "VERSION",
+    "init.rb",
+    "lib/simple_memoize.rb",
+    "rails/init.rb",
+    "simple_memoize.gemspec",
+    "test/test_simple_memoize.rb"
+  ]
+  s.homepage = %q{http://github.com/JackDanger/simple_memoize}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.4.2}
+  s.summary = %q{Very lightweight way to ensure some methods only run once}
+  s.test_files = [
+    "test/test_simple_memoize.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/test_simple_memoize.rb

@@ -8,6 +8,11 @@ module Barks
     'Grrrrr'
   end
   memoize :growl
+
+  def muzzle
+    @growl = false
+  end
+  memoize :muzzle
   
   def protected_growl
     'Grrrrr'
@@ -36,7 +41,12 @@ class Dog
     'slurp'
   end
   memoize :drink
-  
+
+  def hungry?
+    true
+  end
+  memoize :hungry?
+
   class << self
     def breeds
       ['doberman', 'dalmatian']
@@ -52,6 +62,18 @@ class SimpleMemoizeTest < Test::Unit::TestCase
     4.times { dog.growl }
   end
 
+  def test_method_punctuation_carried_to_end_of_method
+    dog = Dog.new
+    dog.expects(:hungry_without_memo?).returns(true).once
+    4.times { dog.hungry? }
+  end
+  
+  def test_module_mehthod_only_calls_memoized_once_for_non_truthy_result
+    dog = Dog.new
+    dog.expects(:muzzle_without_memo).returns(false).once
+    4.times { dog.muzzle }
+  end
+
   def test_module_method_calls_method_several_times
     dog = Dog.new
     dog.expects(:growl).returns('Grrrrr').times(4)
@@ -98,14 +120,16 @@ class SimpleMemoizeTest < Test::Unit::TestCase
   
   def test_protected_methods_remain_protected
     dog = Dog.new
-    assert dog.protected_methods.include?('protected_growl_without_memo')
-    assert dog.protected_methods.include?('protected_growl')
+    methods = dog.protected_methods
+    assert methods.include?('protected_growl_without_memo') || methods.include?( :protected_growl_without_memo )
+    assert methods.include?('protected_growl') || methods.include?( :protected_growl )
   end
   
   def test_private_methods_remain_private
     dog = Dog.new
-    assert dog.private_methods.include?('private_growl_without_memo')
-    assert dog.private_methods.include?('private_growl')
+    methods = dog.private_methods
+    assert methods.include?('private_growl_without_memo') || methods.include?( :private_growl_without_memo )
+    assert methods.include?('private_growl') || methods.include?( :private_growl )
   end
   
   def test_cant_memoize_a_missing_method

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: simple_memoize
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  hash: 21
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Jack Danger Canty
@@ -9,62 +15,62 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-26 00:00:00 -07:00
+date: 2011-04-10 00:00:00 -07: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: Provides in-memory caching of any Ruby method.  It's dead simple and won't get in the way of any of your code. For something more robust that offers persistence try http://github.com/JackDanger/cached_values/
-email: 
-- rubyforge@6brand.com
+dependencies: []
+
+description: 
+email: rubygems@6brand.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- History.txt
-- Manifest.txt
+- LICENSE
 - README.txt
 files: 
-- History.txt
-- Manifest.txt
+- LICENSE
 - README.txt
 - Rakefile
+- VERSION
+- init.rb
 - lib/simple_memoize.rb
+- rails/init.rb
+- simple_memoize.gemspec
 - test/test_simple_memoize.rb
 has_rdoc: true
-homepage: http://github.com/JackDanger/simple_memoize/
+homepage: http://github.com/JackDanger/simple_memoize
+licenses: []
+
 post_install_message: 
-rdoc_options: 
-- --main
-- README.txt
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: objectproxy
-rubygems_version: 1.0.1
+rubyforge_project: 
+rubygems_version: 1.4.2
 signing_key: 
-specification_version: 2
-summary: Provides in-memory caching of any Ruby method
+specification_version: 3
+summary: Very lightweight way to ensure some methods only run once
 test_files: 
 - test/test_simple_memoize.rb

data/History.txt

@@ -1,6 +0,0 @@
-=== 1.0.0 / 2008-03-25
-
-* 1 major enhancement
-
-  * Clean little gem
-

data/Manifest.txt

@@ -1,6 +0,0 @@
-History.txt
-Manifest.txt
-README.txt
-Rakefile
-lib/simple_memoize.rb
-test/test_simple_memoize.rb