memoize 1.2.3 → 1.3.0

data/CHANGES

@@ -1,3 +1,18 @@
+= 1.3.0 - 13-Jul-2009
+* Updated to work with 1.9.x - now passes explicit arguments to super. Still
+  works with 1.8.x as well.
+* Changed license to Artistic 2.0.
+* Removed an unnecessary read attribute when writing to a cache file.
+* Added a warranty section to the README file.
+* Changed the test file name to 'test_memoize.rb' in order to more closely
+  follow Ruby convention.
+* Changed the example file names so that they are each preceded with the
+  text 'example_' to avoid any confusion with test files.
+* The test-unit gem is now a pre-requisite for this library.
+* Added a couple of rake tasks for running example programs.
+* Added a few more tests.
+* Some gemspec updates, including explicit license.
+
 = 1.2.3 - 24-May-2007
 * Added a Rakefile with tasks for testing and installation.
 * Removed the install.rb file. Installation is now handled by the Rakefile tasks.

data/MANIFEST

@@ -3,7 +3,7 @@
 * README
 * Rakefile
 * memoize.gemspec
-* examples/fibonacci.rb
-* examples/test_memoize.rb
+* examples/example_fibonacci.rb
+* examples/example_memoize.rb
 * lib/memoize.rb
-* test/tc_memoize.rb
+* test/test_memoize.rb

data/README

@@ -63,10 +63,15 @@ Memoize#memoize(method, file=nil)
    or the forums at http://www.rubyforge.org/projects/shards.
 
 == License
-   Ruby's
+   Artistic 2.0
+   
+== Warranty
+   This package is provided "as is" and without any express or
+   implied warranties, including, without limitation, the implied
+   warranties of merchantability and fitness for a particular purpose.
 
 == Copyright
-   (C) 2005-2007 Daniel J. Berger
+   (C) 2005-2009 Daniel J. Berger
    All Rights Reserved
 
 = Author

data/Rakefile

@@ -3,22 +3,32 @@ require 'rake/testtask'
 require 'rbconfig'
 include Config
 
-desc 'Install the memoize package (non-gem)'
+desc 'Install the memoize library (non-gem)'
 task :install do
-   sitelibdir = CONFIG["sitelibdir"]
-   file = "lib/memoize.rb"
+   sitelibdir = CONFIG['sitelibdir']
+   file = 'lib/memoize.rb'
    FileUtils.cp(file, sitelibdir, :verbose => true)
 end
 
+desc 'Install the memoize library as a gem'
 task :install_gem do
    ruby 'memoize.gemspec'
-   file = Dir["*.gem"].first
-   sh "gem install #{file}"
+   file = Dir['*.gem'].first
+   sh 'gem install #{file}'
+end
+
+desc 'Run the fibonacci example & benchmarks'
+task :example_fib do
+   ruby '-Ilib examples/example_fibonacci.rb'
+end
+
+desc 'Run the memoize example & benchmarks'
+task :example_memoize do
+   ruby '-Ilib examples/example_memoize.rb'
 end
 
 Rake::TestTask.new do |t|
    t.libs << 'test'
    t.verbose = true
    t.warning = true
-   t.test_files = FileList['test/tc_memoize.rb']
 end

data/examples/example_fibonacci.rb

@@ -0,0 +1,45 @@
+###################################################################
+# fibonacci.rb
+#
+# Demonstrates, via Benchmark, the difference between a memoized
+# version of the fibonnaci method versus a non-memoized version.
+#
+# You can run this via the 'example_fib' rake task.
+###################################################################
+require 'benchmark'
+require 'memoize'
+include Memoize
+
+# Our fibonacci function
+def fib(n)
+   return n if n < 2
+   fib(n-1) + fib(n-2)
+end
+
+file = File.join((ENV['HOME'] || ENV['USERPROFILE']), 'fib.cache')
+
+max_iter = ARGV[0].to_i
+max_fib  = ARGV[1].to_i
+
+max_iter = 100 if max_iter == 0
+max_fib  = 25 if max_fib == 0
+
+print "\nBenchmarking against version: " + MEMOIZE_VERSION + "\n\n"
+
+Benchmark.bm(35) do |x|
+   x.report("Not memoized:"){
+      max_iter.times{ fib(max_fib) }
+   }
+
+   x.report("Memoized:"){
+      memoize(:fib)
+      max_iter.times{ fib(max_fib) }
+   }
+   
+   x.report("Memoized to file:"){
+      memoize(:fib, file)
+      max_iter.times{ fib(max_fib) }
+   }
+end
+
+File.delete(file) if File.exists?(file)

data/examples/example_memoize.rb

@@ -0,0 +1,62 @@
+#################################################################
+# test_memoize.rb
+#
+# Simple example to demonstrate the use of memoize and cache.
+# You can run this via the 'rake example_memoize' task.
+#################################################################
+require "memoize"
+
+puts "MEMOIZE VERSION: " + Memoize::MEMOIZE_VERSION
+
+class Foo
+   include Memoize
+   def fib(n)
+      return n if n < 2
+      fib(n-1) + fib(n-2)
+   end
+
+   def factorial(n)
+     f = 1
+     n.downto(2) { |x| f *= x }
+     return f
+   end
+end
+
+if $0 == __FILE__
+   a = Foo.new
+   b = Foo.new
+   c = Foo.new
+   
+   file = ENV["HOME"] || ENV["USERPROFILE"] + "/fib.cache"
+   
+   cache1 = b.memoize(:fib)
+   cache2 = b.memoize(:factorial)
+   cache3 = c.memoize(:fib, file)
+
+   p cache1
+   b.fib(3)
+   p cache1
+
+   p cache2
+   b.factorial(3)
+   p cache2
+
+   p cache1
+   
+   print "\nWithout memoization\n\n"
+   puts "Start: " + Time.now.to_s
+   a.fib(32)
+   puts "Stop: " + Time.now.to_s 
+
+   print "\n\nWith memoization\n\n"
+   puts "Start: " + Time.now.to_s
+   b.fib(32)
+   puts "Stop: " + Time.now.to_s
+
+   print "\n\nWith memoization to file\n\n"
+   puts "Start: " + Time.now.to_s
+   c.fib(32)
+   puts "Stop: " + Time.now.to_s
+   
+   File.delete(file) if File.exists?(file)
+end

data/lib/memoize.rb

@@ -1,15 +1,15 @@
 module Memoize
-   MEMOIZE_VERSION = "1.2.3"
+   MEMOIZE_VERSION = '1.3.0'
    
    # Memoize the method +name+.  If +file+ is provided, then the method results
    # are stored on disk as well as in memory.
    def memoize(name, file=nil)
-      cache = File.open(file, "rb"){ |io| Marshal.load(io) } rescue {}
+      cache = File.open(file, 'rb'){ |io| Marshal.load(io) } rescue {}
 
       (class<<self; self; end).send(:define_method, name) do |*args|
          unless cache.has_key?(args)
-            cache[args] = super
-            File.open(file, "wb+"){ |f| Marshal.dump(cache, f) } if file
+            cache[args] = super(*args)
+            File.open(file, 'wb'){ |f| Marshal.dump(cache, f) } if file
          end
          cache[args]
       end

data/memoize.gemspec

@@ -0,0 +1,29 @@
+require 'rubygems'
+
+spec = Gem::Specification.new do |gem|
+   gem.name      = 'memoize'
+   gem.version   = '1.3.0'
+   gem.author    = 'Daniel J. Berger'
+   gem.email     = 'djberg96@gmail.com'
+   gem.homepage  = 'http://www.rubyforge.org/projects/shards'
+   gem.platform  = Gem::Platform::RUBY
+   gem.summary   = 'Speeds up methods at the cost of memory (or disk space)'
+   gem.test_file = 'test/test_memoize.rb'
+   gem.has_rdoc  = true
+   gem.files     = Dir['**/*'].reject{ |f| f.include?('CVS') }
+   gem.license   = 'Artistic 2.0'
+
+   gem.rubyforge_project = 'shards'
+   gem.extra_rdoc_files  = ['MANIFEST', 'README', 'CHANGES']
+   
+   gem.add_dependency('test-unit', '>= 2.0.2')
+
+   gem.description = <<-EOF
+      The memoize library allows you to cache methods for faster lookup.
+      Cached results can either be stored in memory (the default) or to
+      a file.
+   EOF
+end
+
+Gem.manage_gems if Gem::RubyGemsVersion.to_f < 1.0
+Gem::Builder.new(spec).build

data/test/{tc_memoize.rb → test_memoize.rb}

@@ -1,18 +1,13 @@
 ###############################################
-# tc_memoize.rb
+# test_memoize.rb
 #
-# Test suite for the memoize package.
+# Test suite for the memoize library.
 ###############################################
-base = File.basename(Dir.pwd)
+require 'rubygems'
+gem 'test-unit'
 
-if base == "test" || base =~ /memoize/
-   Dir.chdir("..") if base == "test"
-   $LOAD_PATH.unshift(Dir.pwd + "/lib")
-   Dir.chdir("test") rescue nil
-end
-
-require "test/unit"
-require "memoize"
+require 'test/unit'
+require 'memoize'
 
 class TC_Memoize < Test::Unit::TestCase
    include Memoize
@@ -20,7 +15,7 @@ class TC_Memoize < Test::Unit::TestCase
    def setup
       @cache1 = nil
       @cache2 = nil
-      @file   = (ENV["HOME"] || ENV["USERPROFILE"]) + "/test.cache"
+      @file   = File.join((ENV['HOME'] || ENV['USERPROFILE']), 'test.cache')
    end
 
    def fib(n)
@@ -35,7 +30,7 @@ class TC_Memoize < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal("1.2.3", Memoize::MEMOIZE_VERSION)
+      assert_equal('1.3.0', Memoize::MEMOIZE_VERSION)
    end
 
    def test_memoize
@@ -53,6 +48,15 @@ class TC_Memoize < Test::Unit::TestCase
       assert_equal(55, fib(10))
    end
 
+   def test_memoize_file_properties
+      assert_false(File.exists?(@file))
+      assert_nothing_raised{ memoize(:fib, @file) }
+      assert_false(File.exists?(@file))
+      assert_nothing_raised{ fib(10) }
+      assert_true(File.exists?(@file))
+      assert_true(File.size(@file) > 0)
+   end
+
    # Ensure that a cache is returned, that it's a hash, and that each
    # memoized method retains its own cache properly.
    def test_memoize_cache

metadata

@@ -1,53 +1,74 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
-specification_version: 1
 name: memoize
 version: !ruby/object:Gem::Version 
-  version: 1.2.3
-date: 2007-05-24 00:00:00 -06:00
-summary: Speeds up methods at the cost of memory (or disk space)
-require_paths: 
-- lib
-email: djberg96@gmail.com
-homepage: http://www.rubyforge.org/projects/shards
-rubyforge_project: 
-description: Speeds up methods at the cost of memory (or disk space)
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.3.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Daniel J. Berger
-files: 
-- lib/memoize.rb
-- CHANGES
-- MANIFEST
-- README
-- Rakefile
-- test/tc_memoize.rb
-test_files: 
-- test/tc_memoize.rb
-rdoc_options: []
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-20 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+    version: 
+description: "      The memoize library allows you to cache methods for faster lookup.\n      Cached results can either be stored in memory (the default) or to\n      a file.\n"
+email: djberg96@gmail.com
+executables: []
+
+extensions: []
 
 extra_rdoc_files: 
 - MANIFEST
 - README
 - CHANGES
-executables: []
-
-extensions: []
+files: 
+- CHANGES
+- examples/example_fibonacci.rb
+- examples/example_memoize.rb
+- lib/memoize.rb
+- MANIFEST
+- memoize.gemspec
+- Rakefile
+- README
+- test/test_memoize.rb
+has_rdoc: true
+homepage: http://www.rubyforge.org/projects/shards
+licenses: 
+- Artistic 2.0
+post_install_message: 
+rdoc_options: []
 
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+rubyforge_project: shards
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Speeds up methods at the cost of memory (or disk space)
+test_files: 
+- test/test_memoize.rb