moneta 0.6.0 → 0.7.0

data/TODO

@@ -1,4 +0,0 @@
-TODO:
-Fix LICENSE with your name
-Fix Rakefile with your name and contact info
-Add your code to lib/<%= name %>.rb

data/lib/moneta/basic_file.rb

@@ -1,111 +0,0 @@
-#
-#  Basic File Store
-#  by Hampton Catlin
-#
-#  This cache simply uses a directory that it creates
-#  and manages to keep your file stores.
-#
-#  Specify :skip_expires => true if you aren't using 
-#  expiration as this will slightly decrease your file size
-#  and memory footprint of the library
-#
-#  You can optionally also specify a :namespace
-#  option that will create a subfolder.
-#
-
-
-require 'fileutils'
-require File.join(File.dirname(__FILE__), "..", "moneta.rb")
-
-module Moneta
-  class BasicFile
-    include Defaults
-    
-    def initialize(options = {})
-      @namespace = options[:namespace]
-      @directory = ::File.join(options[:path], @namespace.to_s)
-      
-      @expires = !options[:skip_expires]
-
-      ensure_directory_created(@directory)
-    end
-    
-    def key?(key)
-      !self[key].nil?
-    end
-    
-    alias has_key? key?
-    
-    def [](key)
-      if ::File.exist?(path(key))
-        data = raw_get(key)
-        if @expires
-          if data[:expires_at].nil? || data[:expires_at] > Time.now
-            data[:value]
-          else
-            delete!(key)
-          end
-        end
-      end
-    end
-    
-    def raw_get(key)
-      Marshal.load(::File.read(path(key)))
-    end
-    
-    def []=(key, value)
-      store(key, value)
-    end
-    
-    def store(key, value, options = {})
-      ensure_directory_created(::File.dirname(path(key)))
-      ::File.open(path(key), "w") do |file|
-        if @expires
-          data = {:value => value}
-          if options[:expires_in]
-            data[:expires_at] = Time.now + options[:expires_in]
-          end
-          contents = Marshal.dump(data)
-        else
-          contents = Marshal.dump(value)
-        end
-        file.puts(contents)
-      end
-    end
-    
-    def update_key(key, options)
-      store(key, self[key], options)
-    end
-    
-    def delete!(key)
-      FileUtils.rm(path(key))
-      nil
-    rescue Errno::ENOENT
-    end
-          
-    def delete(key)
-      value = self[key]
-      delete!(key)
-      value
-    end
-          
-    def clear
-      FileUtils.rm_rf(@directory)
-      FileUtils.mkdir(@directory)
-    end
-    
-    private
-    def path(key)
-      ::File.join(@directory, key.to_s)
-    end
-    
-    def ensure_directory_created(directory_path)
-      if ::File.file?(directory_path)
-        raise StandardError, "The path you supplied #{directory_path} is a file"
-      elsif !::File.exists?(directory_path)
-        FileUtils.mkdir_p(directory_path)
-      end
-    end
-      
-  end
-end

data/lib/moneta/berkeley.rb

@@ -1,53 +0,0 @@
-begin
-  require 'bdb'
-rescue LoadError
-  puts "You need bdb gem to use Bdb moneta store"
-  exit
-end
-
-module Moneta
-
-  class Berkeley
-    include Defaults
-
-    def initialize(options={})
-      file = @file = options[:file]
-      @db = Bdb::Db.new()
-      @db.open(nil, file, nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
-      unless options[:skip_expires]
-        @expiration = Moneta::Berkeley.new(:file => "#{file}_expiration", :skip_expires => true )
-        self.extend(StringExpires)
-      end
-    end
-    
-    module Implementation
-      def key?(key)
-        nil | self[key]
-      end
-
-      alias has_key? key?
-
-      def []=(key,value)
-        @db[key] = value
-      end
-
-      def [](key)
-        @db[key]
-      end
-
-      def delete(key)
-        value = self[key]
-        @db.del(nil,key,0) if value
-        value
-      end
-
-      def clear
-        @db.truncate(nil)
-      end
-    end
-
-    include Implementation
-
-  end
-
-end

data/lib/moneta/couch.rb

@@ -1,63 +0,0 @@
-begin
-  require "couchrest"
-rescue LoadError
-  puts "You need the couchrest gem to use the CouchDB store"
-  exit
-end
-
-module Moneta
-  class Couch
-    include Defaults
-    
-    def initialize(options = {})
-      @db = ::CouchRest.database!(options[:db])
-      unless options[:skip_expires]
-        @expiration = Moneta::Couch.new(:db => "#{options[:db]}_expiration", :skip_expires => true)
-        self.extend(StringExpires)
-      end
-    end
-
-    def key?(key)
-      !self[key].nil?
-    rescue RestClient::ResourceNotFound
-      false
-    end
-
-    alias has_key? key?
-
-    def [](key)
-      @db.get(key)["data"]
-    rescue RestClient::ResourceNotFound
-      nil
-    end
-
-    def []=(key, value)
-      @db.save_doc("_id" => key, :data => value)
-    rescue RestClient::RequestFailed
-      self[key]
-    end
-
-    def delete(key)
-      value = @db.get(key)
-      @db.delete_doc({"_id" => value["_id"], "_rev" => value["_rev"]}) if value
-      value["data"]
-    rescue RestClient::ResourceNotFound
-      nil
-    end
-
-    def update_key(key, options = {})
-      val = self[key]
-      self.store(key, val, options)
-    rescue RestClient::ResourceNotFound
-      nil
-    end
-
-    def clear
-      @db.recreate!
-    end
-
-    def delete_store
-      @db.delete!
-    end
-  end
-end

data/lib/moneta/datamapper.rb

@@ -1,117 +0,0 @@
-begin
-  gem "dm-core", "0.9.10"
-  require "dm-core"
-rescue LoadError
-  puts "You need the dm-core gem in order to use the DataMapper moneta store"
-  exit
-end
-
-class MonetaHash
-  include DataMapper::Resource
-
-  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
-  end
-end
-
-module Moneta
-  class DataMapper
-    class Expiration
-      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(@repository)
-      end
-
-      def delete(key)
-        obj = get(key)
-        obj.expires = nil
-        obj.save(@repository)
-      end
-
-      private
-      def get(key)
-        repository(@repository) { @klass.get(key) }
-      end
-    end
-
-    def initialize(options = {})
-      @repository = options.delete(:repository) || :moneta
-      ::DataMapper.setup(@repository, options[:setup])
-      repository_context { MonetaHash.auto_upgrade! }
-      @hash = MonetaHash
-      @expiration = Expiration.new(MonetaHash, @repository)
-    end
-
-    module Implementation
-      def key?(key)
-        repository_context { !!@hash.get(key) }
-      end
-
-      def has_key?(key)
-        repository_context { !!@hash.get(key) }
-      end
-
-      def [](key)
-        repository_context { @hash.value(key) }
-      end
-
-      def []=(key, value)
-        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, value = nil)
-        repository_context {
-          value ||= block_given? ? yield(key) : default
-          self[key] || value
-        }
-      end
-
-      def delete(key)
-        repository_context {
-          value = self[key]
-          @hash.all(:the_key => key).destroy!
-          value
-        }
-      end
-
-      def store(key, value, options = {})
-        repository_context { self[key] = value }
-      end
-
-      def clear
-        repository_context { @hash.all.destroy! }
-      end
-
-      private
-      def repository_context
-        repository(@repository) { yield }
-      end
-    end
-    include Implementation
-    include Expires
-  end
-end

data/lib/moneta/file.rb

@@ -1,91 +0,0 @@
-begin
-  require "xattr"
-rescue LoadError
-  puts "You need the xattr gem to use the File moneta store"
-  exit
-end
-require "fileutils"
-
-module Moneta
-  class File
-    class Expiration
-      def initialize(directory)
-        @directory = directory
-      end
-      
-      def [](key)
-        attrs = xattr(key)
-        ret = Marshal.load(attrs.get("moneta_expires"))
-      rescue Errno::ENOENT, SystemCallError
-      end
-      
-      def []=(key, value)
-        attrs = xattr(key)
-        attrs.set("moneta_expires", Marshal.dump(value))
-      end
-      
-      def delete(key)
-        attrs = xattr(key)
-        attrs.remove("moneta_expires")
-      end
-
-      private
-      def xattr(key)
-        ::Xattr.new(::File.join(@directory, key))
-      end
-    end
-    
-    def initialize(options = {})
-      @directory = options[:path]
-      if ::File.file?(@directory)
-        raise StandardError, "The path you supplied #{@directory} is a file"
-      elsif !::File.exists?(@directory)
-        FileUtils.mkdir_p(@directory)
-      end
-      
-      @expiration = Expiration.new(@directory)
-    end
-    
-    module Implementation
-      def key?(key)
-        ::File.exist?(path(key))
-      end
-      
-      alias has_key? key?
-      
-      def [](key)
-        if ::File.exist?(path(key))
-          Marshal.load(::File.read(path(key)))
-        end
-      end
-      
-      def []=(key, value)
-        ::File.open(path(key), "w") do |file|
-          contents = Marshal.dump(value)
-          file.puts(contents)
-        end
-      end
-            
-      def delete(key)
-        value = self[key]
-        FileUtils.rm(path(key))
-        value
-      rescue Errno::ENOENT
-      end
-            
-      def clear
-        FileUtils.rm_rf(@directory)
-        FileUtils.mkdir(@directory)
-      end
-      
-      private
-      def path(key)
-        ::File.join(@directory, key.to_s)
-      end
-    end
-    include Implementation
-    include Defaults
-    include Expires
-    
-  end
-end

data/lib/moneta/lmc.rb

@@ -1,52 +0,0 @@
-begin
-  require "localmemcache"
-rescue LoadError
-  puts "You need the localmemcache gem to use the LMC moneta store"
-  exit
-end
-
-module Moneta
-  class Expiration
-    def initialize(hash)
-      @hash = hash
-    end
-    
-    def [](key)         @hash["#{key}__!__expiration"]          end
-    def []=(key, value) @hash["#{key}__!__expiration"] = value  end
-      
-    def delete(key)
-      key = "#{key}__!__expiration"
-      value = @hash[key]
-      @hash.delete(key)
-      value
-    end
-  end
-  
-  class LMC
-    include Defaults
-
-    module Implementation
-      def initialize(options = {})
-        @hash = LocalMemCache.new(:filename => options[:filename])
-        @expiration = Expiration.new(@hash)
-      end    
-
-      def [](key)         @hash[key]          end
-      def []=(key, value) @hash[key] = value  end
-      def clear()         @hash.clear         end
-
-      def key?(key)
-        @hash.keys.include?(key)
-      end
-
-      def delete(key)
-        value = @hash[key]
-        @hash.delete(key)
-        value
-      end      
-    end
-    include Implementation
-    include StringExpires
-   
-  end
-end