juno 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+test/tmp
+*~
+*.swp
+*.rdb

data/.travis.yml

@@ -0,0 +1,25 @@
+rvm:
+  - 1.8.7
+  - 1.9.3
+#  - ruby-head
+#  - jruby
+  - rbx-18mode
+  - rbx-19mode
+services:
+  - riak
+  - couchdb
+  - redis-server
+#  - cassandra
+#  - memcached
+#  - mongodb
+before_install:
+  - sudo apt-get install -qq libtokyocabinet8 libtokyocabinet-dev # tokyotyrant
+  - sudo /bin/bash /etc/init.d/mongodb start
+  - memcached -d -p 22122
+matrix:
+  allow_failures:
+    - rvm: 1.8.7
+#    - rvm: ruby-head
+    - rvm: rbx-18mode
+    - rvm: rbx-19mode
+

data/Gemfile

@@ -0,0 +1,19 @@
+source :rubygems
+gemspec
+
+gem 'activerecord'
+gem 'sqlite3'
+gem 'redis'
+gem 'datamapper'
+gem 'dm-sqlite-adapter'
+gem 'ripple'
+gem 'tokyocabinet'
+gem 'mongo'
+gem 'couchrest'
+gem 'sequel'
+gem 'dalli'
+gem 'memcached'
+#gem 'cassandra'
+#gem 'localmemcache'
+#gem 'fog'
+#gem 'tokyotyrant'

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Yehuda Katz, 2012 Daniel Mendler
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+Juno: A unified interface for key/value stores
+================================================
+
+[![Build Status](https://secure.travis-ci.org/minad/juno.png?branch=master)](http://travis-ci.org/minad/juno) [![Dependency Status](https://gemnasium.com/minad/juno.png?travis)](https://gemnasium.com/minad/juno) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/minad/juno)
+
+Juno provides a standard interface for interacting with various kinds of key/value stores. Juno
+is based on Moneta and replaces it with a mostly compatible interface. The reason for the
+fork was that Moneta was unmaintained for a long time.
+
+Out of the box, it supports:
+
+* File Store
+* Memcached store (memcached and dalli)
+* In-memory store
+* DataMapper
+* BerkeleyDB (dbm)
+* GDBM
+* SDBM
+* Redis
+* Riak
+* TokyoCabinet
+* CouchDB
+* MongoDB
+* ActiveRecord
+* YAML store
+* PStore
+* LocalMemCache
+* Sequel
+* Sqlite3
+
+The Juno API is purposely extremely similar to the Hash API. In order so support an
+identical API across stores, it does not support iteration or partial matches.
+
+The API
+=======
+
+```
+#initialize(options)              options differs per-store, and is used to set up the store
+
+#[](key)                          retrieve a key. if the key is not available, return nil
+
+#fetch(key, options = {}, &block) retrieve a key. if the key is not available, execute the
+                                  block and return its return value.
+
+#fetch(key, value, options = {})  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
+
+#delete(key, options = {})        delete the key from the store and return the current value
+
+#key?(key, options = {})          true if the key exists, false if it does not
+
+#store(key, value, options = {})  same as []=, but you can supply options
+
+#clear(options = {})              clear all keys in this store
+
+#close                            close database connection
+```
+
+Proxy store & Expiry
+====================
+
+The memcached backend supports expires values directly:
+
+```ruby
+cache = Juno::Memcached.new
+# Expires in 10 seconds
+cache.store(key, value, :expires => 10)
+```
+
+You can add the expires feature to other backends using the Expires proxy:
+
+```ruby
+cache = Juno::Expires.new(Juno::File.new(...))
+cache.store(key, value, :expires => 10)
+```
+
+Authors
+=======
+
+* Moneta originally by wycats
+* Juno by Daniel Mendler

data/Rakefile

@@ -0,0 +1,15 @@
+begin
+  require 'bundler'
+  Bundler::GemHelper.install_tasks
+rescue Exception
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = FileList['test/test_*.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/SPEC.md

@@ -0,0 +1,95 @@
+# Juno Specification
+
+The purpose of the juno specification is to create a general-purpose API for interacting with key-value stores. In general, libraries that need to interact with key-value stores should be able to specify that they can use any "juno-compliant store".
+
+# Juno Executable Specs
+
+Juno ships with a set of executable specs which you can use to verify spec-compliance with your juno adapter.
+
+# Juno Library
+
+Juno ships with proof-of-concept adapters for over a dozen key-value stores, including in-memory, memcache, database-backed and S3. These adapters are meant as proofs-of-concept, and while the juno project intends to maintain them (and will accept patches to improve them), you should not consider them the core of the project.
+
+# Requirements for a Juno Adapter
+
+(See RFC 2119 for use of MUST, SHOULD, MAY, MUST NOT, and SHOULD NOT)
+
+A Juno adapter must expose a class with the following characteristics:
+
+## Class Methods
+
+### <code>new(options[Hash]) => Object</code>
+
+Return an instance of the juno adapter, with the instance methods listed below. The <code>options</code> hash is a required parameter, and the adapter may specify whatever additional requirements it needs to properly instantiate it.
+
+## Instance Methods
+
+### <code>\[\](key[Object]) => Object</code>
+
+Return the value stored in the key-value-store under the provided key. Adapters MUST return a duplicate of the original value, and consumers should expect that adapters might serialize and deserialize the key and value. As a result, both the key and value MUST be objects that can be serialized using Ruby's Marshal system.
+
+### <code>\[\]=(key[Object], value[Object]) => Object(value)</code>
+
+Store the value in the key-value-store under the provided key. Adapters MAY serialize the value using Ruby's Marshal system, and MUST NOT store a reference to the original value in the store, unless Ruby disallows duplication of the original value. Adapters SHOULD NOT simply call <code>dup</code> on the value, unless the value stores no references to other Object. For example, an adapter MAY store a <code>dup</code> of a String, but SHOULD NOT store a <code>dup</code> of <code>["hello", "world"]</code>.
+
+### <code>fetch(key[Object]) => Object</code>
+
+Return the value stored in the key-value-store under the provided key. If no value is stored under the provided key, the adapter MUST raise an IndexError.
+
+### <code>fetch(key[Object], &block) => Object</code>
+
+Return the value stored in the key-value-store under the provided key. If no value is stored under the provided key, the adapter MUST yield to the block, and return the value. The adapter MUST NOT store the value returned from the block in the key-value-store.
+
+### <code>fetch(key[Object], value[Object]) => Object</code>
+
+Return the value stored in the key-value-store under the provided key. If no value is stored under the provided key, the adapter MUST return the default value provided. The adapter MUST NOT store the default value in the key-value-store.
+
+### <code>delete(key[Object]) => Object</code>
+
+Delete the value stored in the key-value-store for the key provided, and return the value previously stored there. After this operation, the key-value-store MUST behave as though no value was stored for the provided key.
+
+### <code>key?(key[Object]) => [TrueClass, FalseClass]</code>
+
+Determine whether a value exists in the key-value-store for the key provided. If a value exists, the adapter MUST return <code>true</code>. Otherwise, the adapter MUST return <code>false</code>.
+
+### <code>store(key[Object], value[Object]) => Object(value)</code>
+
+Behaves the same as <code>[]=</code>, but allows the client to send additional options which can be specified by the adapter (and which may be specified by extensions to this specification).
+
+### <code>clear</code>
+
+Completely empty all keys and values from the key-value-store. Adapters MAY allow a namespace during initialization, which can scope this operation to a particular subset of keys. After calling <code>clear</code>, a <code>[]</code> operation MUST return nil for every possible key, and a <code>key?</code> query MUST return false for every possible key.
+
+# Additional Options Hashes
+
+The following methods may all take an additional Hash as a final argument. This allows the client to send additional options which can be specified by the adapter (and which may be specified by extensions to this specification).
+
+* fetch
+* store
+* delete
+* key?
+* clear
+
+In the case of methods with optional arguments, the Hash MUST be provided as the final argument, and all optional arguments MUST be specified.
+
+Keys in this Hash MUST be Strings or Symbols. If they are Strings, they MUST be prefixed with a unique namespace. Namespaces MUST be separated from the name of the key with a single ".". The namespace SHOULD be the name of the gem that exposes the key.
+
+Keys in this Hash MUST NOT be Symbols unless this specification or an official extension to this specification defines a Symbol key.
+
+# Key Equality
+
+Adapters MUST consider keys as equal to one another if and only if the value of <code>Marshal.dump(keya)</code> is the same (byte-for-byte) as <code>Marshal.dump(keyb)</code>. This does not mean that adapters are required to use <code>Marshal.dump</code> to calculate the key to use for a given key specified by the consumer of the adapter. However, if an adapter does not, it MUST guarantee that the value returned for every key is identical to the value that would be returned if it did a byte-for-byte comparison of the result of <code>Marshal.dump</code> for every operation involving a key.
+
+# Storage and Serialization
+
+In a Juno-compliant adapter, any Ruby object that can be serialized using Ruby's marshalling system may be used for keys or values.
+
+Adapters MAY use the marshalling system to serialize Ruby objects. Adapters MUST NOT return an Object from a fetch operation that existed on the heap prior to the fetch operation. The intention of this requirement is to prevent adapters that use the heap for persistence to store direct references to Objects passed into the <code>store</code> or <code>[]=</code> methods.
+
+# Atomicity
+
+The base Juno specification does not specify any atomicity guarantees. However, extensions to this spec may specify extensions that define additional guarantees for any of the defined operations.
+
+# Expiry
+
+The base Juno specification does not specify any mechanism for time-based expiry. However, extensions to this spec may specify mechanisms (using <code>store</code> to provide expiration semantics.

data/juno.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/lib/juno/version'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name = 'juno'
+  s.version = Juno::VERSION
+  s.date = Date.today.to_s
+  s.authors = ['Yehuda Katz', 'Derek Kastner', 'Daniel Mendler']
+  s.email = %w{wycats@gmail.com dkastner@gmail.com mail@daniel-mendler.de}
+  s.description = 'A unified interface to key/value stores (moneta replacement)'
+  s.extra_rdoc_files = %w{README.md SPEC.md LICENSE}
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.homepage = 'http://github.com/minad/juno'
+  s.require_paths = ['lib']
+  s.summary = %{A unified interface to key/value stores, including MongoDB, Redis, Tokyo, and ActiveRecord}
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
+end

data/lib/juno.rb

@@ -0,0 +1,31 @@
+module Juno
+  autoload :ActiveRecord,    'juno/activerecord'
+  autoload :Base,            'juno/base'
+  #autoload :Cassandra,       'juno/cassandra'
+  autoload :Couch,           'juno/couch'
+  autoload :DataMapper,      'juno/datamapper'
+  autoload :DBM,             'juno/dbm'
+  autoload :Expires,         'juno/expires'
+  autoload :File,            'juno/file'
+  #autoload :Fog,             'juno/fog'
+  #autoload :S3,              'juno/fog'
+  #autoload :Rackspace,       'juno/fog'
+  autoload :GDBM,            'juno/gdbm'
+  autoload :HashFile,        'juno/hashfile'
+  autoload :LocalMemCache,   'juno/localmemcache'
+  autoload :Memcached,       'juno/memcached'
+  autoload :MemcachedDalli,  'juno/memcached_dalli'
+  autoload :MemcachedNative, 'juno/memcached_native'
+  autoload :Memory,          'juno/memory'
+  autoload :MongoDB,         'juno/mongodb'
+  autoload :Proxy,           'juno/proxy'
+  autoload :PStore,          'juno/pstore'
+  autoload :Redis,           'juno/redis'
+  autoload :Riak,            'juno/riak'
+  autoload :SDBM,            'juno/sdbm'
+  autoload :Sequel,          'juno/sequel'
+  autoload :Sqlite,          'juno/sqlite'
+  autoload :TokyoCabinet,    'juno/tokyocabinet'
+  #autoload :TokyoTyrant,     'juno/tokyotyrant'
+  autoload :YAML,            'juno/yaml'
+end

data/lib/juno/activerecord.rb

@@ -0,0 +1,58 @@
+require 'active_record'
+
+module Juno
+  class ActiveRecord < Base
+    def self.tables
+      @tables ||= {}
+    end
+
+    attr_reader :table
+
+    def initialize(options = {})
+      table = options[:table] || 'juno'
+      @table = self.class.tables[table] ||= begin
+                                              c = Class.new(::ActiveRecord::Base)
+                                              c.table_name = table
+                                              c
+                                            end
+      @table.establish_connection(options[:connection]) if options[:connection]
+    end
+
+    def migrate
+      @table.connection.create_table @table.table_name do |t|
+        t.string 'key', :primary => :true
+        t.string 'value'
+      end unless @table.table_exists?
+    end
+
+    def key?(key, options = {})
+      !!@table.find_by_key(key_for(key))
+    end
+
+    def [](key)
+      record = @table.find_by_key(key_for(key))
+      record ? deserialize(record.value) : nil
+    end
+
+    def delete(key, options = {})
+      record = @table.find_by_key(key_for(key))
+      if record
+        @table.where(:key => key_for(record.key)).delete_all
+        deserialize(record.value)
+      end
+    end
+
+    def store(key, value, options = {})
+      record = @table.find_by_key(key_for(key))
+      record ||= @table.new(:key => key_for(key))
+      record.value = serialize(value)
+      record.save!
+      value
+    end
+
+    def clear(options = {})
+      @table.delete_all
+      nil
+    end
+  end
+end

data/lib/juno/base.rb

@@ -0,0 +1,113 @@
+module Juno
+  # Simple interface to key/value stores with Hash-like interface.
+  #
+  # @abstract
+  class Base
+    # Exists the value with key
+    #
+    # @param [Object] key
+    # @return [Boolean]
+    # @param [Hash] options
+    # @api public
+    def key?(key, options = {})
+      @store.has_key?(key_for(key))
+    end
+
+    # Fetch value with key. Return nil if the key doesn't exist
+    #
+    # @param [Object] key
+    # @return [Object] value
+    # @api public
+    def [](key)
+      deserialize(@store[key_for(key)])
+    end
+
+    # Store value with key
+    #
+    # @param [Object] key
+    # @param [Object] value
+    # @param [Hash] options
+    # @return value
+    # @api public
+    def store(key, value, options = {})
+      @store[key_for(key)] = serialize(value)
+      value
+    end
+
+    # Delete the key from the store and return the current value
+    #
+    # @param [Object] key
+    # @return [Object] current value
+    # @param [Hash] options
+    # @api public
+    def delete(key, options = {})
+      deserialize(@store.delete(key_for(key)))
+    end
+
+    # Clear all keys in this store
+    #
+    # @param [Hash] options
+    # @return [void]
+    # @api public
+    def clear(options = {})
+      @store.clear
+      nil
+    end
+
+    # Fetch value with key. Return default if value is nil.
+    #
+    # @param [Object] key
+    # @param [Object] value Default value
+    # @param [Hash] options
+    # @return [Object] value from store
+    # @api public
+    def fetch(key, value = nil, options = {})
+      self[key] || (block_given? && yield(key)) || value
+    end
+
+    # Store value with key
+    #
+    # @param [Object] key
+    # @param [Object] value
+    # @return value
+    # @api public
+    def []=(key, value)
+      store(key, value)
+    end
+
+    # Explicitly close the store
+    # @api public
+    def close
+      nil
+    end
+
+    protected
+
+    # Serialize value
+    #
+    # @param [Object] value Serializable object
+    # @return [String] serialized object
+    # @api private
+    def serialize(value)
+      Marshal.dump(value)
+    end
+
+    # Deserialize value
+    #
+    # @param [String] value Serialized object
+    # @return [Object] Deserialized object
+    # @api private
+    def deserialize(value)
+      value && Marshal.load(value)
+    end
+
+    # Convert key to string
+    #
+    # @param [Object] key Key
+    # @return [String] Marshalled key
+    # @api private
+    def key_for(key)
+      String === key ? key : Marshal.dump(key)
+    end
+  end
+end