juno 0.2.4 → 0.2.5

data/Gemfile

@@ -7,10 +7,11 @@ gem 'rspec'
 gem 'parallel_tests'
 
 # Serializer
-#gem 'tnetstring'
+gem 'tnetstring'
+gem 'bert'
+gem 'bencode'
 gem 'bson'
 gem 'multi_json'
-gem 'json' # Ripple/Riak needs json
 
 # Backends
 gem 'dm-core'
@@ -27,9 +28,13 @@ gem 'riak-client'
 gem 'hashery'
 
 if defined?(JRUBY_VERSION)
+  gem 'msgpack-jruby'
   gem 'jdbc-sqlite3'
   gem 'activerecord-jdbc-adapter'
   gem 'activerecord-jdbcsqlite3-adapter'
+  gem 'jruby-memcached'
+  gem 'ffi' # gdbm for jruby needs ffi
+  gem 'gdbm'
 else
   gem 'msgpack'
   gem 'tokyocabinet'

data/README.md

@@ -10,7 +10,7 @@ fork was that Moneta was unmaintained for a long time.
 Juno is very feature rich:
 
 * Supports for a lot of backends (See below)
-* Supports proxies (Similar to [Rack middlewares](http://rack.rubyforge.org/))
+* Supports proxies (Similar to [Rack middlewares](http://rack.github.com/))
 * Custom serialization via `Juno::Transformer` proxy (Marshal/JSON/YAML and many more)
 * Custom key transformation via `Juno::Transformer` proxy
 * Expiration for all stores (Added via proxy if not supported natively)
@@ -58,11 +58,12 @@ Supported serializers:
 * MessagePack
 * BSON
 * Ox
+* BERT
 
 Proxies
 -------
 
-In addition it supports proxies (Similar to [Rack middlewares](http://rack.rubyforge.org/)) which
+In addition it supports proxies (Similar to [Rack middlewares](http://rack.github.com/)) which
 add additional features to storage backends:
 
 * `Juno::Proxy` proxy base class
@@ -71,6 +72,7 @@ add additional features to storage backends:
 * `Juno::Transformer` transforms keys and values (Marshal, YAML, JSON, Base64, MD5, ...)
 * `Juno::Cache` combine two stores, one as backend and one as cache (e.g. Juno::Adapters::File + Juno::Adapters::Memory)
 * `Juno::Lock` to make store thread safe
+* `Juno::Logger` to log database accesses
 
 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.

data/lib/juno/adapters/memcached_native.rb

@@ -16,6 +16,7 @@ module Juno
       def initialize(options = {})
         server = options.delete(:server) || 'localhost:11211'
         options.merge!(:prefix_key => options.delete(:namespace)) if options[:namespace]
+        @default_ttl = options[:default_ttl] || 604800
         @cache = ::Memcached.new(server, options)
       end
 
@@ -44,7 +45,8 @@ module Juno
       end
 
       def store(key, value, options = {})
-        @cache.set(key, value, options[:expires] || @cache.options[:default_ttl], false)
+        # TTL must be Fixnum
+        @cache.set(key, value, options[:expires] || @default_ttl, false)
         value
       end
 

data/lib/juno/builder.rb

@@ -4,24 +4,23 @@ module Juno
   class Builder
     def build
       klass, options, block = @proxies.first
-      store = klass.new(@options.merge(options), &block)
+      store = klass.new(options, &block)
       @proxies[1..-1].each do |proxy|
         klass, options, block = proxy
-        store = klass.new(store, @options.merge(options), &block)
+        store = klass.new(store, options, &block)
       end
       store
     end
 
-    def initialize(options = {}, &block)
+    def initialize(&block)
       raise 'No block given' unless block_given?
-      raise 'Options must be Hash' unless Hash === options
-      @options = options
       @proxies = []
       instance_eval(&block)
     end
 
     def use(proxy, options = {}, &block)
       proxy = Juno.const_get(proxy) if Symbol === proxy
+      raise 'You must give a Class or a Symbol' unless Class === proxy
       @proxies.unshift [proxy, options, block]
     end
 

data/lib/juno/cache.rb

@@ -18,14 +18,16 @@ module Juno
         instance_eval(&block)
       end
 
-      def backend(options = {}, &block)
+      def backend(store = nil, &block)
         raise 'Backend already set' if @backend
-        @backend = Hash === options ? Juno.build(options, &block) : options
+        raise 'Only argument or block allowed' if store && block
+        @backend = store || Juno.build(&block)
       end
 
-      def cache(options = {}, &block)
+      def cache(store = nil, &block)
         raise 'Cache already set' if @cache
-        @cache = Hash === options ? Juno.build(options, &block) : options
+        raise 'Only argument or block allowed' if store && block
+        @cache = store || Juno.build(&block)
       end
 
       def result

data/lib/juno/expires.rb

@@ -1,5 +1,9 @@
 module Juno
   # Adds expiration support to the underlying store
+  #
+  # #store and #load support the :expires options to set/update
+  # the expiration time.
+  #
   # @api public
   class Expires < Proxy
     def key?(key, options = {})

data/lib/juno/lock.rb

@@ -4,9 +4,16 @@ module Juno
   # Locks the underlying stores with a Mutex
   # @api public
   class Lock < Proxy
+    # Constructor
+    #
+    # @param [Juno store] adapter The underlying store
+    # @param [Hash] options
+    #
+    # Options:
+    # * :mutex - Mutex object (default Mutex.new)
     def initialize(adapter, options = {})
       super
-      @lock = Mutex.new
+      @lock = options[:mutex] || Mutex.new
     end
 
     def key?(key, options = {})

data/lib/juno/logger.rb

@@ -0,0 +1,86 @@
+module Juno
+  # Logger proxy
+  # @api public
+  class Logger < Proxy
+    # Standard formatter used by the logger
+    # @api public
+    class Format
+      def initialize(options)
+        @prefix = options[:prefix] || 'Juno '
+        @out = options[:out] || STDOUT
+      end
+
+      def call(entry)
+        @out.write(format(entry))
+      end
+
+      protected
+
+      def format(entry)
+        args = entry[:args]
+        args.pop if Hash === args.last && args.last.empty?
+        args = args.map {|a| dump(a) }.join(', ')
+        if entry[:error]
+          "#{@prefix}#{entry[:method]}(#{args}) raised error: #{entry[:error].message}\n"
+        else
+          "#{@prefix}#{entry[:method]}(#{args}) -> #{dump entry[:return]}\n"
+        end
+      end
+
+      def dump(value)
+        value = value.inspect
+        value.size > 30 ? value[0..30] + '...' : value
+      end
+    end
+
+    # Constructor
+    #
+    # @param [Juno store] adapter The underlying store
+    # @param [Hash] options
+    #
+    # Options:
+    # * :logger - Callable logger object (default Juno::Logger::Format)
+    # * :logprefix - Prefix string (default 'Juno ')
+    # * :logout - Output (default STDOUT)
+    def initialize(adapter, options = {})
+      super
+      @logger = options[:logger] || Format.new(options)
+    end
+
+    def key?(key, options = {})
+      log(:key?, key, options) { super }
+    end
+
+    def load(key, options = {})
+      log(:load, key, options) { super }
+    end
+
+    def store(key, value, options = {})
+      log(:store, key, value, options) { super }
+    end
+
+    def delete(key, options = {})
+      log(:delete, key, options) { super }
+    end
+
+    def clear(options = {})
+      log(:clear, options) { super; nil }
+      self
+    end
+
+    def close
+      log(:close) { super }
+    end
+
+    protected
+
+    def log(method, *args)
+      ret = yield
+      @logger.call(:method => method, :args => args, :return => ret)
+      ret
+    rescue Exception => error
+      @logger.call(:method => method, :args => args, :error => error)
+      raise
+    end
+  end
+end

data/lib/juno/proxy.rb

@@ -4,6 +4,10 @@ module Juno
   class Proxy < Base
     attr_reader :adapter
 
+    # Constructor
+    #
+    # @param [Juno store] underlying adapter
+    # @param [Hash] options
     def initialize(adapter, options = {})
       @adapter = adapter
     end

data/lib/juno/stack.rb

@@ -22,8 +22,9 @@ module Juno
         instance_eval(&block)
       end
 
-      def add(options = {}, &block)
-        @stack << (Hash === options ? Juno.build(options, &block) : options)
+      def add(store = nil, &block)
+        raise 'Only argument or block allowed' if store && block
+        @stack << (store || Juno.build(&block))
         nil
       end
     end

data/lib/juno/transformer.rb

@@ -11,29 +11,35 @@ module Juno
   # @api public
   class Transformer < Proxy
     VALUE_TRANSFORMER = {
-      :marshal  => { :load => '::Marshal.load(VALUE)',          :dump => '::Marshal.dump(VALUE)' },
-      :ox       => { :load => '::Ox.parse_obj(VALUE)',          :dump => '::Ox.dump(VALUE)', :require => 'ox' },
-      :base64   => { :load => "VALUE.unpack('m').first",        :dump => "[VALUE].pack('m').strip" },
-      :json     => { :load => '::MultiJson.load(VALUE).first',  :dump => '::MultiJson.dump([VALUE])', :require => 'multi_json' },
-      :yaml     => { :load => '::YAML.load(VALUE)',             :dump => '::YAML.dump(VALUE)', :require => 'yaml' },
-      #:tnet    => { :load => '::TNetstring.parse(VALUE)',      :dump => '::TNetstring.dump(VALUE)', :require => 'tnetstring' },
-      :msgpack  => { :load => '::MessagePack.unpack(VALUE)',    :dump => '::MessagePack.pack(VALUE)', :require => 'msgpack' },
-      :bson     => { :load => '::BSON.deserialize(VALUE)["v"]', :dump => '::BSON.serialize({"v"=>VALUE})', :require => 'bson' },
-      :compress => { :load => '::Zlib::Inflate.inflate(VALUE)', :dump => '::Zlib::Deflate.deflate(VALUE)', :require => 'zlib' },
+      :base64   => { :load => "value.unpack('m').first",         :dump => "[value].pack('m').strip" },
+      :bencode  => { :load => '::BEncode.load(value)',           :dump => '::BEncode.dump(value)', :require => 'bencode' },
+      :bert     => { :load => '::BERT.decode(value)',            :dump => '::BERT.encode(value)', :require => 'bert' },
+      :bson     => { :load => "::BSON.deserialize(value)['v']",  :dump => "::BSON.serialize('v'=>value)", :require => 'bson' },
+      :compress => { :load => '::Zlib::Inflate.inflate(value)',  :dump => '::Zlib::Deflate.deflate(value)', :require => 'zlib' },
+      :json     => { :load => '::MultiJson.load(value).first',   :dump => '::MultiJson.dump([value])', :require => 'multi_json' },
+      :marshal  => { :load => '::Marshal.load(value)',           :dump => '::Marshal.dump(value)' },
+      :msgpack  => { :load => '::MessagePack.unpack(value)',     :dump => '::MessagePack.pack(value)', :require => 'msgpack' },
+      :ox       => { :load => '::Ox.parse_obj(value)',           :dump => '::Ox.dump(value)', :require => 'ox' },
+      :tnet     => { :load => '::TNetstring.parse(value).first', :dump => '::TNetstring.dump(value)', :require => 'tnetstring' },
+      :uuencode => { :load => "value.unpack('u').first",         :dump => "[value].pack('u').strip" },
+      :yaml     => { :load => '::YAML.load(value)',              :dump => '::YAML.dump(value)', :require => 'yaml' }
     }
 
     KEY_TRANSFORMER = {
-      :base64  => { :transform => "[KEY].pack('m').strip" },
-      :spread  => { :transform => '(TMP = KEY; ::File.join(TMP[0..1], TMP[2..-1]))' },
-      :escape  => { :transform => "KEY.gsub(/[^a-zA-Z0-9_-]+/) { '%%' + $&.unpack('H2' * $&.bytesize).join('%%').upcase }" },
-      :md5     => { :transform => '::Digest::MD5.hexdigest(KEY)', :require => 'digest/md5' },
-      :json    => { :transform => '(TMP = KEY; String === TMP ? TMP : ::MultiJson.dump(TMP))', :require => 'multi_json' },
-      :bson    => { :transform => '(TMP = KEY; String === TMP ? TMP : ::BSON.serialize({"k"=>TMP}).to_s)', :require => 'bson' },
-      :yaml    => { :transform => '(TMP = KEY; String === TMP ? TMP : ::YAML.dump(TMP))', :require => 'yaml' },
-      :marshal => { :transform => '(TMP = KEY; String === TMP ? TMP : ::Marshal.dump(TMP))' },
-      :ox      => { :transform => '(TMP = KEY; String === TMP ? TMP : ::Ox.dump(TMP))' },
-      #:tnet   => { :transform => '(TMP = KEY; String === TMP ? TMP : ::TNetstring.dump(TMP))', :require => 'tnetstring' },
-      :msgpack => { :transform => '(TMP = KEY; String === TMP ? TMP : ::MessagePack.pack(TMP))', :require => 'msgpack' },
+      :base64   => { :transform => "[key].pack('m').strip" },
+      :bencode  => { :transform => '::BEncode.dump(key)', :require => 'bencode' },
+      :bert     => { :transform => '::BERT.encode(key)', :require => 'bert' },
+      :bson     => { :transform => "(tmp = key; String === tmp ? tmp : ::BSON.serialize('k'=>tmp).to_s)", :require => 'bson' },
+      :escape   => { :transform => "key.gsub(/[^a-zA-Z0-9_-]+/) { '%%' + $&.unpack('H2' * $&.bytesize).join('%%').upcase }" },
+      :json     => { :transform => '(tmp = key; String === tmp ? tmp : ::MultiJson.dump(tmp))', :require => 'multi_json' },
+      :marshal  => { :transform => '(tmp = key; String === tmp ? tmp : ::Marshal.dump(tmp))' },
+      :md5      => { :transform => '::Digest::MD5.hexdigest(key)', :require => 'digest/md5' },
+      :msgpack  => { :transform => '(tmp = key; String === tmp ? tmp : ::MessagePack.pack(tmp))', :require => 'msgpack' },
+      :ox       => { :transform => '(tmp = key; String === tmp ? tmp : ::Ox.dump(tmp))' },
+      :spread   => { :transform => '(tmp = key; ::File.join(tmp[0..1], tmp[2..-1]))' },
+      :tnet     => { :transform => '(tmp = key; String === tmp ? tmp : ::TNetstring.dump(tmp))', :require => 'tnetstring' },
+      :uuencode => { :transform => "[key].pack('u').strip" },
+      :yaml     => { :transform => '(tmp = key; String === tmp ? tmp : ::YAML.dump(tmp))', :require => 'yaml' },
     }
 
     @classes = {}
@@ -46,76 +52,70 @@ module Juno
         keys.each do |tn|
           raise "Unknown key transformer #{tn}" unless t = KEY_TRANSFORMER[tn]
           require t[:require] if t[:require]
-          key = t[:transform].gsub('KEY', key).gsub('TMP', "x#{tmp}")
+          key = t[:transform].gsub('key', key).gsub('tmp', "x#{tmp}")
           tmp += 1
         end
 
         klass = Class.new(Transformer)
         if values.empty?
           klass.class_eval <<-end_eval, __FILE__, __LINE__
-              def key?(key, options = {})
-                @adapter.key?(#{key}, options)
-              end
-
-              def load(key, options = {})
-                @adapter.load(#{key}, options)
-              end
-
-              def store(key, value, options = {})
-                @adapter.store(#{key}, value, options)
-              end
-
-              def delete(key, options = {})
-                @adapter.delete(#{key}, options)
-              end
-            end_eval
+            def key?(key, options = {})
+              @adapter.key?(#{key}, options)
+            end
+            def load(key, options = {})
+              @adapter.load(#{key}, options)
+            end
+            def store(key, value, options = {})
+              @adapter.store(#{key}, value, options)
+            end
+            def delete(key, options = {})
+              @adapter.delete(#{key}, options)
+            end
+          end_eval
         else
           dumper, loader = 'value', 'value'
           values.each_index do |i|
             raise "Unknown value transformer #{values[i]}" unless t = VALUE_TRANSFORMER[values[i]]
             require t[:require] if t[:require]
-            dumper = t[:dump].gsub('VALUE', dumper)
-            loader = VALUE_TRANSFORMER[values[-i-1]][:load].gsub('VALUE', loader)
+            dumper = t[:dump].gsub('value', dumper)
+            loader = VALUE_TRANSFORMER[values[-i-1]][:load].gsub('value', loader)
           end
 
           klass.class_eval <<-end_eval, __FILE__, __LINE__
-              def key?(key, options = {})
-                @adapter.key?(#{key}, options)
-              end
-
-              def load(key, options = {})
-                value = @adapter.load(#{key}, options)
-                value && #{loader}
-              end
-
-              def store(key, value, options = {})
-                @adapter.store(#{key}, #{dumper}, options)
-                value
-              end
-
-              def delete(key, options = {})
-                value = @adapter.delete(#{key}, options)
-                value && #{loader}
-              end
-            end_eval
+            def key?(key, options = {})
+              @adapter.key?(#{key}, options)
+            end
+            def load(key, options = {})
+              value = @adapter.load(#{key}, options)
+              value && #{loader}
+            end
+            def store(key, value, options = {})
+              @adapter.store(#{key}, #{dumper}, options)
+              value
+            end
+            def delete(key, options = {})
+              value = @adapter.delete(#{key}, options)
+              value && #{loader}
+            end
+          end_eval
         end
         klass
       end
 
       # Constructor
       #
-      # @param [Juno store] store The underlying store
+      # @param [Juno store] adapter The underlying store
       # @param [Hash] options
       #
       # Options:
       # * :key - List of key transformers in the order in which they should be applied
       # * :value - List of value transformers in the order in which they should be applied
-      def new(store, options = {})
+      def new(adapter, options = {})
         keys = [options[:key]].flatten.compact
         values = [options[:value]].flatten.compact
         raise 'No option :key or :value specified' if keys.empty? && values.empty?
         klass = @classes["#{keys.join('-')}+#{values.join('-')}"] ||= compile(keys, values)
-        klass.original_new(store, options)
+        klass.original_new(adapter, options)
       end
     end
   end

data/lib/juno/version.rb

@@ -1,5 +1,5 @@
 module Juno
   # Juno version number
   # @api public
-  VERSION = '0.2.4'
+  VERSION = '0.2.5'
 end

data/lib/juno.rb

@@ -4,6 +4,7 @@ module Juno
   autoload :Cache,             'juno/cache'
   autoload :Expires,           'juno/expires'
   autoload :Lock,              'juno/lock'
+  autoload :Logger,            'juno/logger'
   autoload :Proxy,             'juno/proxy'
   autoload :Stack,             'juno/stack'
   autoload :Transformer,       'juno/transformer'
@@ -44,9 +45,10 @@ module Juno
   # @param [Hash] options
   #
   # Options:
-  # * :expires - Ensure that store supports expiration by inserting
+  # * :expires - If options is true, ensure that store supports expiration by inserting
   #   Juno::Expires if the underlying adapter doesn't support it natively
-  # * :threadsafe - Ensure that the store is thread safe by inserting Juno::Lock
+  # * :threadsafe - If options is true, ensure that the store is thread safe by inserting Juno::Lock
+  # * :logger - If options is a true or Hash, add logger to chain (Hash is passed to logger as options)
   # * All other options passed to the adapter
   #
   # Supported adapters:
@@ -56,6 +58,7 @@ module Juno
   # * ... (All other adapters from Juno::Adapters)
   def self.new(name, options = {})
     expires = options.delete(:expires)
+    logger = options.delete(:logger)
     threadsafe = options.delete(:threadsafe)
     transformer = {:key => :marshal, :value => :marshal}
     raise 'Name must be Symbol' unless Symbol === name
@@ -82,25 +85,24 @@ module Juno
       # Expires already supported
       expires = false
     end
-    build(options) do
+    build do
+      use :Logger, Hash === logger ? logger : {} if logger
       use :Expires if expires
       use :Transformer, transformer
       use :Lock if threadsafe
-      adapter name
+      adapter name, options
     end
   end
 
   # Build your own store chain!
   #
-  # @params [Hash] options Options passed to the proxies and adapter
-  #
   # Example:
   #
   #     Juno.build do
   #       use :Expires
   #       adapter :Memory
   #     end
-  def self.build(options = {}, &block)
-    Builder.new(options, &block).build
+  def self.build(&block)
+    Builder.new(&block).build
   end
 end

data/spec/adapter_activerecord_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_activerecord" do
@@ -21,7 +21,7 @@ describe_juno "adapter_activerecord" do
     ActiveRecord::Base.establish_connection :adapter => (defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'), :database => File.join(make_tempdir, 'activerecord-existing')
 
     store = Juno::Adapters::ActiveRecord.new
-    store.table.table_exists?.should == true
+    store.table.should be_table_exists
   end
 
 end

data/spec/adapter_cassandra_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_cassandra" do

data/spec/adapter_couch_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_couch" do

data/spec/adapter_datamapper_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_datamapper" do

data/spec/adapter_dbm_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_dbm" do

data/spec/adapter_file_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_file" do

data/spec/adapter_fog_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_fog" do

data/spec/adapter_gdbm_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_gdbm" do

data/spec/adapter_localmemcache_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_localmemcache" do

data/spec/adapter_lruhash_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_lruhash" do

data/spec/adapter_memcached_dalli_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_memcached_dalli" do

data/spec/adapter_memcached_native_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_memcached_native" do

data/spec/adapter_memcached_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_memcached" do

data/spec/adapter_memory_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_memory" do

data/spec/adapter_mongo_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_mongo" do

data/spec/adapter_pstore_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_pstore" do

data/spec/adapter_redis_spec.rb

@@ -1,4 +1,4 @@
-# Generated by generate.rb at 2012-12-02 18:03:24 +0100, heads/master-0-g9a90bb4
+# Generated by generate.rb
 require 'helper'
 
 describe_juno "adapter_redis" do