thoughtless-moneta 0.6.0.1 → 0.6.0.2

data/README

@@ -31,6 +31,11 @@ The API:
 
 #[](key)::                      retrieve a key. if the key is not available, return nil
 
+#fetch(key, &block)::           retrieve a key. if the key is not available, execute the
+                                block and return its return value.
+
+#fetch(key, value)              retrieve a key. if the key is not available, return the value
+
 #[]=(key, value)::              set a value for a key. if the key is already used, clobber it.
                                 keys set using []= will never expire
 
@@ -40,7 +45,7 @@ The API:
 
 #has_key?(key)::                alias for key?
 
-#store(key, value, options)::   same as []=, but you can supply an :expires_in option, 
+#store(key, value, options)::   same as []=, but you can supply an :expires_in option,
                                 which will specify a number of seconds before the key
                                 should expire. In order to support the same features
                                 across all stores, only full seconds are supported

data/Rakefile

@@ -5,7 +5,7 @@ require 'spec/rake/spectask'
 require 'date'
 
 GEM = "thoughtless-moneta"
-GEM_VERSION = "0.6.0.1"
+GEM_VERSION = "0.6.0.2"
 AUTHOR = "Yehuda Katz"
 EMAIL = "wycats@gmail.com"
 HOMEPAGE = "http://www.yehudakatz.com"

data/lib/moneta.rb

@@ -1,77 +1,30 @@
+require "moneta/builder"
+
 module Moneta
-  MONETA_VERSION = '0.6.0.1'
-  module Expires
-    def check_expired(key)
-      if @expiration[key] && Time.now > @expiration[key]
-        @expiration.delete(key)
-        self.delete(key)
+  MONETA_VERSION = '0.6.0.2'
+  module Defaults
+    def fetch(key, value = nil, *)
+      self[key] || begin
+        value ||= block_given? ? yield(key) : default
+        self[key] || value
       end
     end
 
-    def key?(key)
-      check_expired(key)
-      super
-    end
-
-    def [](key)
-      check_expired(key)
-      super
-    end
-
-    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)
+    def []=(key, value)
+      store(key, value)
     end
 
-    def store(key, value, options = {})
-      ret = super(key, value)
-      update_options(key, options)
-      ret
+  private
+    def key_for(key)
+      key.is_a?(String) ? key : Marshal.dump(key)
     end
 
-    private
-    def update_options(key, options)
-      if options[:expires_in]
-        @expiration[key] = (Time.now + options[:expires_in])
-      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
+    def serialize(value)
+      Marshal.dump(value)
     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
+    def deserialize(value)
+      value && Marshal.load(value)
     end
-    
-    def store(key, value, options = {})
-      self[key] = value
-    end        
   end
 end

data/lib/moneta/adapters/basic_file.rb

@@ -0,0 +1,84 @@
+#
+#  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 "moneta"
+
+module Moneta
+  module Adapters
+    class BasicFile
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        @namespace = options[:namespace]
+        @directory = ::File.join(options[:path], @namespace.to_s)
+
+        ensure_directory_created(@directory)
+      end
+
+      def key?(key, *)
+        !self[key].nil?
+      end
+
+      def [](key)
+        if ::File.exist?(path(key))
+          raw_get(key)
+        end
+      end
+
+      def store(key, value, *)
+        ensure_directory_created(::File.dirname(path(key)))
+        ::File.open(path(key), "w") do |file|
+          file.puts(serialize(value))
+        end
+      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_for(key))
+      end
+
+      def raw_get(key)
+        deserialize(::File.read(path(key)))
+      end
+
+      def delete!(key)
+        FileUtils.rm(path(key))
+        nil
+      rescue Errno::ENOENT
+      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
+end

data/lib/moneta/adapters/couch.rb

@@ -0,0 +1,51 @@
+begin
+  require "couchrest"
+rescue LoadError
+  puts "You need the couchrest gem to use the CouchDB store"
+  exit
+end
+
+module Moneta
+  module Adapters
+    class Couch
+      include Defaults
+
+      def initialize(options = {})
+        @db = ::CouchRest.database!(options[:db])
+      end
+
+      def key?(key, *)
+        !self[key_for(key)].nil?
+      rescue RestClient::ResourceNotFound
+        false
+      end
+
+      def [](key)
+        deserialize(@db.get(key_for(key))["data"])
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+
+      def store(key, value, *)
+        @db.save_doc("_id" => key_for(key), :data => serialize(value))
+      rescue RestClient::RequestFailed
+        self[key_for(key)]
+      end
+
+      def delete(key, *)
+        value = @db.get(key_for(key))
+
+        if value
+          @db.delete_doc({"_id" => value["_id"], "_rev" => value["_rev"]}) if value
+          deserialize(value["data"])
+        end
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+
+      def clear(*)
+        @db.recreate!
+      end
+    end
+  end
+end

data/lib/moneta/adapters/datamapper.rb

@@ -0,0 +1,76 @@
+begin
+  gem "dm-core", "~> 1.0.0"
+  gem "dm-migrations", "~> 1.0.0"
+  gem "dm-sqlite-adapter", "~> 1.0.0"
+  require "dm-core"
+  require "dm-migrations"
+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
+
+  def self.value(key)
+    obj = self.get(key)
+    obj && obj.value
+  end
+end
+
+module Moneta
+  module Adapters
+    class DataMapper
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        @repository = options.delete(:repository) || :moneta
+        ::DataMapper.setup(@repository, options[:setup])
+        MonetaHash.auto_upgrade!(@repository)
+        @hash = MonetaHash
+      end
+
+      def key?(key, *)
+        repository_context { !!@hash.get(key_for(key)) }
+      end
+
+      def [](key)
+        repository_context { @hash.value(key_for(key)) }
+      end
+
+      def store(key, value, *)
+        string_key = key_for(key)
+        repository_context {
+          obj = @hash.get(string_key)
+          if obj
+            obj.update(string_key, value)
+          else
+            @hash.create(:the_key => string_key, :value => value)
+          end
+        }
+      end
+
+      def delete(key, *)
+        string_key = key_for(key)
+
+        repository_context {
+          value = self[key]
+          @hash.all(:the_key => string_key).destroy!
+          value
+        }
+      end
+
+      def clear(*)
+        repository_context { @hash.all.destroy! }
+      end
+
+    private
+      def repository_context
+        repository(@repository) { yield }
+      end
+    end
+  end
+end

data/lib/moneta/adapters/file.rb

@@ -0,0 +1,52 @@
+require "fileutils"
+
+module Moneta
+  module Adapters
+    class File
+      include Moneta::Defaults
+
+      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
+      end
+
+      def key?(key, *)
+        ::File.exist?(path(key))
+      end
+
+      def [](key)
+        if ::File.exist?(path(key))
+          Marshal.load(::File.read(path(key)))
+        end
+      end
+
+      def store(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_for(key))
+      end
+    end
+  end
+end

data/lib/moneta/adapters/fog.rb

@@ -0,0 +1,62 @@
+begin
+  require "fog"
+rescue LoadError
+  puts "You need the Fog gem to use the S3 moneta store"
+  exit
+end
+
+module Moneta
+  module Adapters
+    class Fog
+      include Moneta::Defaults
+
+      def initialize(options = {})
+        bucket = options.delete(:namespace)
+        s3 = options.delete(:cloud).new(options)
+        @directory = s3.directories.create(:key => bucket)
+      end
+
+      def key?(key)
+        !@directory.files.head(key_for(key)).nil?
+      end
+
+      def [](key)
+        if value = get(key)
+          deserialize(value.body)
+        end
+      end
+
+      def delete(key)
+        value = get(key)
+        if value
+          value.destroy
+          deserialize(value.body)
+        end
+      end
+
+      def store(key, value, options = {})
+        #perms = options[:perms]
+        #headers = options[:headers] || {}
+        @directory.files.create(:key => key_for(key), :body => serialize(value))
+      end
+
+      # def update_key(key, options = {})
+      #   debug "update_key(key=#{key}, options=#{options.inspect})"
+      #   k = s3_key(key, false)
+      #   k.save_meta(meta_headers_from_options(options)) unless k.nil?
+      # end
+
+      def clear
+        @directory.files.all.each do |file|
+          file.destroy
+        end
+        self
+      end
+
+    private
+      def get(key)
+        @directory.files.get(key_for(key))
+      end
+    end
+  end
+end