remember 0.0.2 → 0.0.5

data/lib/remember.rb

@@ -1,56 +1,38 @@
-require 'moneta'
+require "forwardable"
+require "moneta"
 
 class Remember
-  def initialize(moneta, options = {})
-    @moneta = moneta.new(options)
-  end
-  
-  def []=(key, object)
-    store(key, object)
+  extend Forwardable
+
+  attr_accessor :moneta
+  def_delegators :moneta, :clear, :key?, :has_key?
+
+  def initialize(moneta)
+    self.moneta = moneta
   end
 
   def store(key, object, options = {})
-    @moneta.store(key, Marshal.dump(object), options)
-    object
+    object.tap { |value| moneta.store(key, Marshal.dump(value), options) }
   end
 
-  def update_key(key, options = {})
-    if @moneta.key?(key)
-      @moneta.update_key(key, options)
-    end
-  end
-  
-  def fetch(key, options, &block)
-    if value = self[key]
-      value
-    else
-      store(key, yield, options)
-    end
-  end
-  
-  def [](key)
-    deserialize(@moneta[key])
+  def get(key)
+    deserialize(moneta[key])
   end
 
   def delete(key)
-    deserialize(@moneta.delete(key))
-  end
-  
-  def key?(key)
-    @moneta.key?(key)
+    deserialize(moneta.delete(key))
   end
-  
-  def clear
-    @moneta.clear
+
+  def fetch(key, options = {}, &block)
+    get(key) || store(key, yield, options)
   end
-  
-  alias has_key? key?
-  
+
+  alias_method :[], :get
+  alias_method :[]=, :store
+
   private
-  
-    def deserialize(value)
-      if value && value.size > 0
-        Marshal.load(value)
-      end
-    end
-end
+
+  def deserialize(value)
+    Marshal.load(value) if value && value.size > 0
+  end
+end

metadata

@@ -1,69 +1,78 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: remember
-version: !ruby/object:Gem::Version 
-  version: 0.0.2
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - John Pignata
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2009-11-16 00:00:00 -05:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-11-14 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: moneta
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
+  requirement: &70188720542740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
         version: 0.6.0
-    version: 
-description: A Moneta wrapper for Ruby object persistence
-email: john.pignata@gmail.com
+  type: :runtime
+  prerelease: false
+  version_requirements: *70188720542740
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70188720542160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: *70188720542160
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70188720541640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *70188720541640
+description: Quick hack to build quick persistence between application instances
+email: john@pignata.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README.md
-files: 
-- README.md
-- Rakefile
-- VERSION
-- doc/remember.jpg
+extra_rdoc_files: []
+files:
 - lib/remember.rb
-- spec/remember_spec.rb
-has_rdoc: true
 homepage: http://github.com/jpignata/remember
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+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: 
+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: 
-rubygems_version: 1.3.5
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: A Moneta wrapper for Ruby object persistence
-test_files: 
-- spec/remember_spec.rb
+test_files: []

data/README.md

@@ -1,53 +0,0 @@
-# Remember
-
-![Remember](/jpignata/remember/raw/master/doc/remember.jpg)
-
-A simple object persistence wrapper for Moneta. Initialize Remember with any Moneta adapter and serialize any object that implements Ruby's marshal API.
-
-## Adapters
-
-Moneta currently supports:
-
-* File store for xattr
-* Basic File Store
-* Memcache store
-* In-memory store
-* The xattrs in a file system
-* DataMapper
-* S3
-* Berkeley DB
-* Redis
-* SDBM
-* Tokyo
-* CouchDB
-
-## Usage
-
-    jp@populuxe:~/Projects/remember$ irb -r 'lib/remember' -r 'moneta/redis'
-    >> r = Remember.new(Moneta::Redis)
-    >> r["important_data"] = rand(100000000000000000000000)
-    => 99924367975800373618177
-    >> r["important_data"]
-    => 99924367975800373618177
-    >> r["config"] = { :setting => 'value', :other_setting => 'other value' }
-
-    jp@populuxe:~/Projects/remember$ irb -r 'lib/remember' -r 'moneta/redis'
-    >> r = Remember.new(Moneta::Redis)
-    >> r["important_data"]
-    => 99924367975800373618177
-    >> r["config"]
-    => {:setting=>"value", :other_setting=>"other value"}
-		
-    jp@populuxe:~/Projects/remember$ irb -r 'lib/remember' -r 'moneta/redis'
-    >> r = Remember.new(Moneta::Redis)
-    >> class Duck; def make_noise; "Quack!"; end; end
-    >> d = Duck.new
-    >> d.make_noise
-    => "Quack!"
-    >> r["duck"] = d
-
-    jp@populuxe:~/Projects/remember$ irb -r 'lib/remember' -r 'moneta/redis'
-    >> r = Remember.new(Moneta::Redis)
-    >> class Duck; def make_noise; "Quack!"; end; end
-    >> r["duck"].make_noise
-    => "Quack!"

data/Rakefile

@@ -1,23 +0,0 @@
-require 'rake'
-require 'spec/rake/spectask'
-
-begin  
-  require 'jeweler'  
-  Jeweler::Tasks.new do |gemspec|  
-    gemspec.name = "remember"  
-    gemspec.summary = "A Moneta wrapper for Ruby object persistence"  
-    gemspec.description = "A Moneta wrapper for Ruby object persistence"  
-    gemspec.email = "john.pignata@gmail.com"  
-    gemspec.homepage = "http://github.com/jpignata/remember"  
-    gemspec.authors = ["John Pignata"]
-    gemspec.add_dependency("moneta", "0.6.0")
-  end 
-  Jeweler::GemcutterTasks.new 
-rescue LoadError  
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"  
-end
-
-Spec::Rake::SpecTask.new(:spec) do |t|
-  t.spec_files = FileList['spec/*_spec.rb']
-  t.spec_opts = ['--color', '--format specdoc']
-end

data/VERSION

@@ -1 +0,0 @@
-0.0.2

data/spec/remember_spec.rb

@@ -1,131 +0,0 @@
-require File.join(File.dirname(__FILE__), '../lib/remember')
-require 'moneta/memory'
-
-describe Remember do
-  before do
-    @r = Remember.new(Moneta::Memory)
-  end
-  
-  describe "#[]=" do
-    it "returns the Object originally passed into it" do
-      @r["enum_sizes"] = ['xs', 's', 'm', 'l'].should == ['xs', 's', 'm', 'l']
-    end
-    
-    it "persists object values and behaviors" do
-      class Bridge < Struct.new(:name, :year)
-        def to_s; "#{name} opened in #{year}"; end
-        def opened?; year < Time.now.year; end
-      end
-      
-      @r["brooklyn"] = Bridge.new("Brooklyn Bridge", 1883)
-      @r["verrazano"] = Bridge.new("Verrazano-Narrows Bridge", 1964)
-
-      @r["brooklyn"].to_s.should == "Brooklyn Bridge opened in 1883"
-      @r["verrazano"].year.should == 1964
-      @r["brooklyn"].opened?.should be_true
-    end
-  end
-
-  describe "#[]" do
-    context "a given key exists" do
-      it "returns a deserialized object" do
-        @r["thirteen"] = 13
-        @r["thirteen"].should == 13
-      end
-    end
-
-    context "a given key does not exist" do
-      it "returns nil" do
-        @r["pretend"].should be_nil
-      end
-    end
-  end
-  
-  describe "#delete" do
-    context "a given key exists" do
-      it "returns the object that the key contained after deletion" do
-        @r["thirteen"] = 13
-        @r.delete("thirteen").should == 13
-        @r["thirteen"].should be_nil
-      end      
-    end
-
-    context "a given key does not exist" do    
-      it "returns nil" do
-        @r.delete("pretend").should be_nil
-      end
-    end
-  end
-  
-  describe "#key?" do
-    context "a key that exists" do
-      it "returns true" do
-        @r["real"] = true
-        @r.key?("real").should be_true
-      end
-    end
-
-    context "a key that does not exist" do
-      it "returns false" do
-        @r.key?("pretend").should be_false
-      end
-    end
-  end
-  
-  describe "#has_key?" do
-    it "is an alias for key?" do
-      @r.has_key?("pretend").should == @r.key?("pretend")
-    end
-  end
-
-  describe "#clear" do
-    it "clears all persisted objects" do
-      @r["do"] = 1
-      @r["ray"] = 2
-      @r["egon"] = 3
-      @r.clear
-      @r.key?("ray").should be_false
-    end
-  end    
-  
-  describe "#store" do
-    it "saves an object to key and sets an expiration in seconds" do
-      @r.store("zuul", :zuul, :expires_in => 60).should == :zuul
-    end
-  end
-
-  describe "#update_key" do
-    context "a key that exists" do
-      it "updates object identified by key and sets an expiration in seconds and returns the new expiration time" do
-        @r["gozer"] = :gozer
-        @r.update_key("gozer", :expires_in => 60).to_i.should == Time.now.to_i + 60
-      end
-    end
-
-    context "a key that does not exist" do
-      it "returns nil" do
-        @r.update_key("slimer", :expires_in => 60).should be_nil
-      end
-    end
-  end
-  
-  describe "#fetch" do
-    context "a key that exists" do
-      it "fetches the object" do
-        @r["some_data"] = 123
-        @r.fetch("some_data", :expires_in => 120) { 456 }.should == 123
-      end
-    end
-
-    context "a key that does not exist" do
-      it "executes a block and then stores the resulting object" do
-        @r["resource_intensive_data"].should be_nil
-        data = @r.fetch("resource_intensive_data", :expires_in => 120) do
-          ['calculation']
-        end
-        data.should == ['calculation']
-        @r["resource_intensive_data"].should == ['calculation']
-      end      
-    end
-  end
-end