wycats-moneta 0.5.0 → 0.6.0

data/README

@@ -10,6 +10,12 @@ Out of the box, it supports:
 * In-memory store
 * The xattrs in a file system
 * DataMapper
+* S3
+* Berkeley DB
+* Redis
+* SDBM
+* Tokyo
+* CouchDB
 
 All stores support key expiration, but only memcache supports it natively. All other stores
 emulate expiration.

data/lib/moneta.rb

@@ -6,40 +6,37 @@ module Moneta
         self.delete(key)
       end
     end
-    
-    def has_key?(key)
+
+    def key?(key)
       check_expired(key)
       super
     end
-    
-    def key?(key)
-      has_key?(key)
-    end
-    
+
     def [](key)
       check_expired(key)
       super
     end
-    
-    def fetch(key, default)
+
+    def fetch(key, default = nil, &blk)
       check_expired(key)
       super
     end
-    
+
     def delete(key)
       check_expired(key)
       super
     end
-        
+
     def update_key(key, options)
-      update_options(key, options)      
+      update_options(key, options)
     end
-    
+
     def store(key, value, options = {})
-      super(key, value)
+      ret = super(key, value)
       update_options(key, options)
+      ret
     end
-    
+
     private
     def update_options(key, options)
       if options[:expires_in]
@@ -47,4 +44,33 @@ module Moneta
       end
     end
   end
-end
+
+  module StringExpires
+    include Expires
+
+    def check_expired(key)
+      if @expiration[key] && Time.now > Time.at(@expiration[key].to_i)
+        @expiration.delete(key)
+        delete(key)
+      end
+    end
+
+    private
+    def update_options(key, options)
+      if options[:expires_in]
+        @expiration[key] = (Time.now + options[:expires_in]).to_i.to_s
+      end
+    end
+  end
+  
+  module Defaults
+    def fetch(key, value = nil)
+      value ||= block_given? ? yield(key) : default
+      self[key] || value
+    end
+    
+    def store(key, value, options = {})
+      self[key] = value
+    end        
+  end
+end

data/lib/moneta/datamapper.rb

@@ -8,15 +8,11 @@ end
 
 class MonetaHash
   include DataMapper::Resource
-  
-  def self.default_repository_name
-    :moneta
-  end
-  
+
   property :the_key, String, :key => true
   property :value, Object, :lazy => false
   property :expires, Time
-  
+
   def self.value(key)
     obj = self.get(key)
     obj && obj.value
@@ -26,79 +22,93 @@ end
 module Moneta
   class DataMapper
     class Expiration
-      def initialize(klass)
+      def initialize(klass, repository)
         @klass = klass
+        @repository = repository
       end
-      
+
       def [](key)
         if obj = get(key)
           obj.expires
         end
       end
-      
+
       def []=(key, value)
         obj = get(key)
         obj.expires = value
-        obj.save
+        obj.save(@repository)
       end
-      
+
       def delete(key)
         obj = get(key)
         obj.expires = nil
-        obj.save
+        obj.save(@repository)
       end
-      
+
       private
       def get(key)
-        @klass.get(key)
+        repository(@repository) { @klass.get(key) }
       end
     end
-    
+
     def initialize(options = {})
-      ::DataMapper.setup(:moneta, options[:setup])
-      MonetaHash.auto_upgrade!
+      @repository = options.delete(:repository) || :moneta
+      ::DataMapper.setup(@repository, options[:setup])
+      repository_context { MonetaHash.auto_upgrade! }
       @hash = MonetaHash
-      @expiration = Expiration.new(MonetaHash)
+      @expiration = Expiration.new(MonetaHash, @repository)
     end
-    
+
     module Implementation
       def key?(key)
-        !!@hash.get(key)
+        repository_context { !!@hash.get(key) }
       end
-      
+
       def has_key?(key)
-        !!@hash.get(key)
+        repository_context { !!@hash.get(key) }
       end
-      
+
       def [](key)
-        @hash.value(key)
+        repository_context { @hash.value(key) }
       end
 
       def []=(key, value)
-        obj = @hash.get(key)
-        if obj
-          obj.update(key, value)
-        else
-          @hash.create(:the_key => key, :value => value)
-        end
+        repository_context {
+          obj = @hash.get(key)
+          if obj
+            obj.update(key, value)
+          else
+            @hash.create(:the_key => key, :value => value)
+          end
+        }
       end
-      
-      def fetch(key, default)
-        self[key] || default
+
+      def fetch(key, value = nil)
+        repository_context {
+          value ||= block_given? ? yield(key) : default
+          self[key] || value
+        }
       end
-      
+
       def delete(key)
-        value = self[key]
-        @hash.all(:the_key => key).destroy!
-        value
+        repository_context {
+          value = self[key]
+          @hash.all(:the_key => key).destroy!
+          value
+        }
       end
-      
+
       def store(key, value, options = {})
-        self[key] = value
+        repository_context { self[key] = value }
       end
-      
+
       def clear
-        @hash.all.destroy!
+        repository_context { @hash.all.destroy! }
+      end
+
+      private
+      def repository_context
+        repository(@repository) { yield }
       end
     end
     include Implementation

data/lib/moneta/file.rb

@@ -1,10 +1,10 @@
 begin
-  require "fileutils"
   require "xattr"
 rescue LoadError
   puts "You need the xattr gem to use the File moneta store"
   exit
 end
+require "fileutils"
 
 module Moneta
   class File
@@ -40,7 +40,7 @@ module Moneta
       if ::File.file?(@directory)
         raise StandardError, "The path you supplied #{@directory} is a file"
       elsif !::File.exists?(@directory)
-        FileUtils.mkdir(@directory)
+        FileUtils.mkdir_p(@directory)
       end
       
       @expiration = Expiration.new(@directory)
@@ -51,9 +51,7 @@ module Moneta
         ::File.exist?(path(key))
       end
       
-      def has_key?(key)
-        ::File.exist?(path(key))
-      end
+      alias has_key? key?
       
       def [](key)
         if ::File.exist?(path(key))
@@ -67,22 +65,14 @@ module Moneta
           file.puts(contents)
         end
       end
-      
-      def fetch(key, default)
-        self[key] || default
-      end
-      
+            
       def delete(key)
         value = self[key]
         FileUtils.rm(path(key))
         value
       rescue Errno::ENOENT
       end
-      
-      def store(key, value, options = {})
-        self[key] = value
-      end
-      
+            
       def clear
         FileUtils.rm_rf(@directory)
         FileUtils.mkdir(@directory)
@@ -94,6 +84,7 @@ module Moneta
       end
     end
     include Implementation
+    include Defaults
     include Expires
     
   end

data/lib/moneta/memcache.rb

@@ -1,52 +1,52 @@
 begin
+  require "memcached"
+rescue LoadError
   require "memcache"
 rescue LoadError
   puts "You need the memcache gem to use the Memcache moneta store"
-  exit  
+  exit
 end
 
-module Moneta  
+module Moneta
   class Memcache
+    include Defaults
+    
     def initialize(options = {})
       @cache = MemCache.new(options.delete(:server), options)
     end
-    
+
     def key?(key)
-      !self["key"].nil?
+      !self[key].nil?
     end
-    
+
     alias has_key? key?
-    
+
     def [](key)
       @cache.get(key)
     end
-    
+
     def []=(key, value)
       store(key, value)
     end
-    
-    def fetch(key, default)
-      self[key] || default
-    end
-    
+
     def delete(key)
       value = self[key]
       @cache.delete(key) if value
       value
     end
-    
+
     def store(key, value, options = {})
       args = [key, value, options[:expires_in]].compact
       @cache.set(*args)
     end
-    
+
     def update_key(key, options = {})
       val = self[key]
       self.store(key, val, options)
     end
-    
+
     def clear
       @cache.flush_all
     end
   end
-end
+end

data/lib/moneta/xattr.rb

@@ -8,6 +8,7 @@ require "fileutils"
 
 module Moneta
   class Xattr
+    include Defaults
     
     def initialize(options = {})
       file = options[:file]
@@ -26,9 +27,7 @@ module Moneta
         @hash.list.include?(key)
       end
       
-      def has_key?(key)
-        @hash.list.include?(key)
-      end
+      alias has_key? key?
       
       def [](key)
         return nil unless key?(key)
@@ -39,10 +38,6 @@ module Moneta
         @hash.set(key, Marshal.dump(value))
       end
       
-      def fetch(key, value)
-        self[key] || value
-      end
-      
       def delete(key)
         return nil unless key?(key)
         value = self[key]
@@ -50,10 +45,6 @@ module Moneta
         value
       end
       
-      def store(key, value, options = {})
-        self[key] = value
-      end
-      
       def clear
         @hash.list.each do |item|
           @hash.remove(item)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: wycats-moneta
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Yehuda Katz