juno 0.2.7 → 0.2.8

data/README.md

@@ -210,6 +210,22 @@ use Rack::Cache,
       :entity_store => 'juno://named_entitystore'
 ~~~
 
+Use Juno to store cookies in Rack:
+
+~~~ ruby
+require 'rack/juno_cookies'
+
+use Rack::JunoCookies, :domain => 'example.com', :path => '/path'
+run lambda { |env|
+  req = Rack::Request.new(env)
+  req.cookies #=> is now a Juno store!!
+  req.cookies['key'] #=> retrieves 'key'
+  req.cookies['key'] = 'value' #=> sets 'key'
+  req.cookies.delete('key') #=> removes 'key'
+  [200,{},[]]
+}
+~~~
+
 Alternatives
 ------------
 
@@ -221,5 +237,6 @@ Alternatives
 Authors
 -------
 
-* Juno by Daniel Mendler
-* Moneta originally by wycats
+* Daniel Mendler
+* Hannes Georg
+* Moneta originally by Yehuda Katz and contributors

data/Rakefile

@@ -15,7 +15,7 @@ namespace :test do
       puts 'No tests executed in parallel in JRuby'
     else
       specs = Dir['spec/*/*_spec.rb'].reject {|s| s =~ /memcached|redis/ }
-      sh("parallel_rspec -m 15 #{specs.join(' ')}")
+      sh("parallel_rspec -m 5 #{specs.join(' ')}")
     end
   end
 

data/juno.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.name             = 'juno'
   s.version          = Juno::VERSION
   s.date             = Date.today.to_s
-  s.authors          = ['Daniel Mendler', 'Yehuda Katz', 'Derek Kastner']
-  s.email            = %w{mail@daniel-mendler.de wycats@gmail.com dkastner@gmail.com}
+  s.authors          = ['Daniel Mendler', 'Hannes Georg']
+  s.email            = %w{mail@daniel-mendler.de hannes.georg@googlemail.com}
   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")

data/lib/juno.rb

@@ -12,6 +12,7 @@ module Juno
   module Adapters
     autoload :ActiveRecord,    'juno/adapters/activerecord'
     autoload :Cassandra,       'juno/adapters/cassandra'
+    autoload :Cookie,          'juno/adapters/cookie'
     autoload :Couch,           'juno/adapters/couch'
     autoload :DataMapper,      'juno/adapters/datamapper'
     autoload :DBM,             'juno/adapters/dbm'
@@ -108,13 +109,12 @@ module Juno
 
   # Build your own store chain!
   #
-  # Example:
-  #
-  #     Juno.build do
-  #       use :Expires
-  #       adapter :Memory
-  #     end
+  # @example Juno builder
+  #   Juno.build do
+  #     use :Expires
+  #     adapter :Memory
+  #   end
   def self.build(&block)
-    Builder.new(&block).build
+    Builder.new(&block).build.last
   end
 end

data/lib/juno/adapters/cookie.rb

@@ -0,0 +1,35 @@
+module Juno
+  module Adapters
+    class Cookie < Memory
+      attr_reader :cookies
+
+      def initialize(options = {})
+        super
+        @options, @cookies = options, {}
+      end
+
+      def store(key, value, options = {})
+        cookie = @options.merge(options)
+        cookie[:value] = value
+        cookie[:expires] += Time.now.to_i if cookie[:expires]
+        @cookies[key] = cookie
+        super
+      end
+
+      def delete(key, options = {})
+        @cookies[key] = nil
+        super
+      end
+
+      def clear(options = {})
+        @memory.each_key { |key| @cookies[key] = nil }
+        super
+        self
+      end
+
+      def reset(cookies)
+        @cookies, @memory = {}, cookies
+      end
+    end
+  end
+end

data/lib/juno/builder.rb

@@ -5,12 +5,10 @@ module Juno
     # @api private
     def build
       klass, options, block = @proxies.first
-      store = klass.new(options, &block)
-      @proxies[1..-1].each do |proxy|
+      @proxies[1..-1].inject([klass.new(options, &block)]) do |stores, proxy|
         klass, options, block = proxy
-        store = klass.new(store, options, &block)
+        stores << klass.new(stores.last, options, &block)
       end
-      store
     end
 
     def initialize(&block)

data/lib/juno/cache.rb

@@ -1,8 +1,7 @@
 module Juno
   # Combines two stores. One is used as cache, the other as backend.
   #
-  # Example:
-  #
+  # @example Add cache to chain
   #   Juno.build do
   #     use(:Cache) do
   #      backend { adapter :File, :dir => 'data' }

data/lib/juno/stack.rb

@@ -2,8 +2,7 @@ module Juno
   # Combines multiple stores. Reads return the result from the first store,
   # writes go to all stores.
   #
-  # Example:
-  #
+  # @example Add stack to chain
   #   Juno.build do
   #     use(:Stack) do
   #       add { adapter :Redis }

data/lib/juno/transformer.rb

@@ -1,8 +1,7 @@
 module Juno
   # Transforms keys and values (Marshal, YAML, JSON, Base64, MD5, ...).
   #
-  # Example:
-  #
+  # @example Add transformer to chain
   #   Juno.build do
   #     transformer :key => [:marshal, :escape], :value => [:marshal]
   #     adapter :File, :dir => 'data'
@@ -10,50 +9,6 @@ module Juno
   #
   # @api public
   class Transformer < Proxy
-    # Available value transformers (Encoding and decoding)
-    VALUE_TRANSFORMER = {
-      :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' },
-      :json     => { :load => '::MultiJson.load(value).first',   :dump => '::MultiJson.dump([value])', :require => 'multi_json' },
-      :lzma     => { :load => '::LZMA.decompress(value)',        :dump => '::LZMA.compress(value)', :require => 'lzma' },
-      :lzo      => { :load => '::LZO.decompress(value)',         :dump => '::LZO.compress(value)', :require => 'lzoruby' },
-      :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' },
-      :snappy   => { :load => '::Snappy.inflate(value)',         :dump => '::Snappy.deflate(value)', :require => 'snappy' },
-      :quicklz  => { :load => '::QuickLZ.decompress(value)',     :dump => '::QuickLZ.compress(value)', :require => 'qlzruby' },
-      :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' },
-      :zlib     => { :load => '::Zlib::Inflate.inflate(value)',  :dump => '::Zlib::Deflate.deflate(value)', :require => 'zlib' },
-    }
-
-    # Available key transformers (Only encoding, one direction)
-    KEY_TRANSFORMER = {
-      :base64   => { :transform => "[key].pack('m').strip" },
-      :bencode  => { :transform => '(tmp = key; String === tmp ? tmp : ::BEncode.dump(tmp))', :require => 'bencode' },
-      :bert     => { :transform => '(tmp = key; String === tmp ? tmp : ::BERT.encode(tmp))', :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' },
-      :prefix   => { :transform => '@prefix+key' },
-      :rmd160   => { :transform => '::Digest::RMD160.hexdigest(key)', :require => 'digest/rmd160' },
-      :ox       => { :transform => '(tmp = key; String === tmp ? tmp : ::Ox.dump(tmp))', :require => 'ox' },
-      :sha1     => { :transform => '::Digest::SHA1.hexdigest(key)', :require => 'digest/sha1' },
-      :sha256   => { :transform => '::Digest::SHA256.hexdigest(key)', :require => 'digest/sha2' },
-      :sha384   => { :transform => '::Digest::SHA384.hexdigest(key)', :require => 'digest/sha2' },
-      :sha512   => { :transform => '::Digest::SHA512.hexdigest(key)', :require => 'digest/sha2' },
-      :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' },
-    }
-
     def initialize(adapter, options = {})
       super
       @prefix = options[:prefix]
@@ -86,13 +41,10 @@ module Juno
       private
 
       def compile(keys, values)
-        tmp, key = 0, 'key'
-        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}")
-          tmp += 1
-        end
+        raise 'Invalid key transformer chain' if KEY_TRANSFORMER !~ keys.map(&:inspect).join
+        raise 'Invalid value transformer chain' if VALUE_TRANSFORMER !~ values.map(&:inspect).join
+
+        key = compile_transformer(keys, 'key')
 
         klass = Class.new(Transformer)
         if values.empty?
@@ -111,13 +63,8 @@ module Juno
             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)
-          end
+          dump = compile_transformer(values, 'value')
+          load = compile_transformer(values.reverse, 'value', 1)
 
           klass.class_eval <<-end_eval, __FILE__, __LINE__
             def key?(key, options = {})
@@ -125,20 +72,78 @@ module Juno
             end
             def load(key, options = {})
               value = @adapter.load(#{key}, options)
-              value && #{loader}
+              value && #{load}
             end
             def store(key, value, options = {})
-              @adapter.store(#{key}, #{dumper}, options)
+              @adapter.store(#{key}, #{dump}, options)
               value
             end
             def delete(key, options = {})
               value = @adapter.delete(#{key}, options)
-              value && #{loader}
+              value && #{load}
             end
           end_eval
         end
         klass
       end
+
+      # Compile transformer validator regular expression
+      def compile_validator(s)
+        Regexp.new(s.gsub(/\w+/) do
+                     '(' + TRANSFORMER.select {|k,v| v.first.to_s == $& }.map {|v| ":#{v.first}" }.join('|') + ')'
+                   end.gsub(/\s+/, '').sub(/\A/, '\A').sub(/\Z/, '\Z'))
+      end
+
+      # Returned compiled transformer code string
+      def compile_transformer(transformer, var, i = 2)
+        transformer.inject(var) do |value, name|
+          raise "Unknown transformer #{name}" unless t = TRANSFORMER[name]
+          require t[3] if t[3]
+          code = t[i]
+          if t[0] == :serialize && var == 'key'
+            "(tmp = #{value}; String === tmp ? tmp : #{code.gsub('value', 'tmp')})"
+          else
+            code.gsub('value', value)
+          end
+        end
+      end
     end
+
+    # Available key/value transformers
+    TRANSFORMER = {
+      # Name    => [ Type,       Load,                              Dump,                                Library         ],
+      :bencode  => [ :serialize, '::BEncode.load(value)',           '::BEncode.dump(value)',             'bencode'       ],
+      :bert     => [ :serialize, '::BERT.decode(value)',            '::BERT.encode(value)',              'bert'          ],
+      :bson     => [ :serialize, "::BSON.deserialize(value)['v']",  "::BSON.serialize('v'=>value).to_s", 'bson'          ],
+      :json     => [ :serialize, '::MultiJson.load(value).first',   '::MultiJson.dump([value])',         'multi_json'    ],
+      :marshal  => [ :serialize, '::Marshal.load(value)',           '::Marshal.dump(value)'                              ],
+      :msgpack  => [ :serialize, '::MessagePack.unpack(value)',     '::MessagePack.pack(value)',         'msgpack'       ],
+      :ox       => [ :serialize, '::Ox.parse_obj(value)',           '::Ox.dump(value)',                  'ox'            ],
+      :tnet     => [ :serialize, '::TNetstring.parse(value).first', '::TNetstring.dump(value)',          'tnetstring'    ],
+      :yaml     => [ :serialize, '::YAML.load(value)',              '::YAML.dump(value)',                'yaml'          ],
+      :lzma     => [ :compress,  '::LZMA.decompress(value)',        '::LZMA.compress(value)',            'lzma'          ],
+      :lzo      => [ :compress,  '::LZO.decompress(value)',         '::LZO.compress(value)',             'lzoruby'       ],
+      :snappy   => [ :compress,  '::Snappy.inflate(value)',         '::Snappy.deflate(value)',           'snappy'        ],
+      :quicklz  => [ :compress,  '::QuickLZ.decompress(value)',     '::QuickLZ.compress(value)',         'qlzruby'       ],
+      :zlib     => [ :compress,  '::Zlib::Inflate.inflate(value)',  '::Zlib::Deflate.deflate(value)',    'zlib'          ],
+      :base64   => [ :encode,    "value.unpack('m').first",         "[value].pack('m').strip"                            ],
+      :uuencode => [ :encode,    "value.unpack('u').first",         "[value].pack('u').strip"                            ],
+      :escape   => [ :encode,    "value.gsub(/((?:%[0-9a-fA-F]{2})+)/){ [$1.delete('%')].pack('H*') }",
+                                 "value.gsub(/[^a-zA-Z0-9_-]+/){ '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase }" ],
+      :md5      => [ :digest,    nil,                               '::Digest::MD5.hexdigest(value)',    'digest/md5'    ],
+      :rmd160   => [ :digest,    nil,                               '::Digest::RMD160.hexdigest(value)', 'digest/rmd160' ],
+      :sha1     => [ :digest,    nil,                               '::Digest::SHA1.hexdigest(value)',   'digest/sha1'   ],
+      :sha256   => [ :digest,    nil,                               '::Digest::SHA256.hexdigest(value)', 'digest/sha2'   ],
+      :sha384   => [ :digest,    nil,                               '::Digest::SHA384.hexdigest(value)', 'digest/sha2'   ],
+      :sha512   => [ :digest,    nil,                               '::Digest::SHA512.hexdigest(value)', 'digest/sha2'   ],
+      :prefix   => [ :prefix,    nil,                               '@prefix+value'                                      ],
+      :spread   => [ :spread,    nil,                               '(tmp = value; ::File.join(tmp[0..1], tmp[2..-1]))'  ],
+    }
+
+    # Allowed value transformers (Read it like a regular expression!)
+    VALUE_TRANSFORMER = compile_validator('serialize? compress? encode?')
+
+    # Allowed key transformers (Read it like a regular expression!)
+    KEY_TRANSFORMER = compile_validator('serialize? prefix? (encode | (digest spread?))?')
   end
 end

data/lib/juno/version.rb

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

data/lib/rack/juno_cookies.rb

@@ -0,0 +1,62 @@
+require 'juno'
+require 'rack/utils'
+
+module Rack
+  # A Rack middleware that was made to reuse all juno transformers
+  # on the cookie hash.
+  #
+  # @example config.ru
+  #   # Add Rack::JunoCookies somewhere in your rack stack
+  #   use Rack::JunoCookies
+  #
+  #   run lambda{|env| [200,{},[]] }
+  #   # But this doesn't do much
+  #
+  # @example config.ru
+  #   # Give it some options
+  #   use Rack::JunoCookies, :domain => 'example.com', :path => '/path'
+  #
+  # @example config.ru
+  #   # Pass it a block like the one passed to Juno.build
+  #   use Rack::JunoCookies do
+  #     use :Transformer, :key => :prefix, :prefix => 'juno.'
+  #     adapter :Cookie
+  #   end
+  #
+  #   run lambda { |env|
+  #     req = Rack::Request.new(env)
+  #     req.cookies #=> is now a Juno store!!
+  #     req.cookies['key'] #=> retrieves 'juno.key'
+  #     req.cookies['key'] = 'value' #=> sets 'juno.key'
+  #     req.cookies.delete('key') #=> removes 'juno.key'
+  #     [200,{},[]]
+  #   }
+  #
+  class JunoCookies
+    def initialize(app, options = {}, &block)
+      @app = app
+      if block
+        raise 'Use either block or options' unless options.empty?
+        @builder = Juno::Builder.new(&block)
+      else
+        @builder = Juno::Builder.new { adapter :Cookie, options }
+      end
+    end
+
+    def call(env)
+      stores = @builder.build
+      env['rack.request.cookie_hash'] = stores.last
+      env['rack.request.cookie_string'] = env['HTTP_COOKIE']
+      stores.first.reset(Rack::Utils.parse_query(env['HTTP_COOKIE']))
+      status, headers, body = @app.call(env)
+      stores.first.cookies.each do |key, cookie|
+        if cookie == nil
+          Rack::Utils.delete_cookie_header!(headers, key)
+        else
+          Rack::Utils.set_cookie_header!(headers, key, cookie)
+        end
+      end
+      [status, headers, body]
+    end
+  end
+end

data/spec/generate.rb

@@ -576,6 +576,10 @@ end
     :build => "Juno::Adapters::Cassandra.new",
     :specs => ADAPTER_SPECS
   },
+  'adapter_cookie' => {
+    :build => 'Juno::Adapters::Cookie.new',
+    :specs => ADAPTER_SPECS
+  },
   'adapter_couch' => {
     :build => "Juno::Adapters::Couch.new(:db => 'adapter_couch')",
     :specs => ADAPTER_SPECS

data/spec/juno/adapter_cookie_spec.rb

@@ -0,0 +1,13 @@
+# Generated by generate.rb
+require 'helper'
+
+describe_juno "adapter_cookie" do
+  def new_store
+    Juno::Adapters::Cookie.new
+  end
+
+  include_context 'setup_store'
+  it_should_behave_like 'null_stringkey_stringvalue'
+  it_should_behave_like 'store_stringkey_stringvalue'
+  it_should_behave_like 'returndifferent_stringkey_stringvalue'
+end

data/spec/rack/juno_cookies_spec.rb

@@ -0,0 +1,81 @@
+require 'helper'
+require 'rack/mock'
+require 'rack/juno_cookies'
+
+describe Rack::JunoCookies do
+  def config(options={},&block)
+    @options = options
+    @block = block
+  end
+
+  def app(&block)
+    @app_block ||= block
+  end
+
+  def backend
+    Rack::MockRequest.new(Rack::JunoCookies.new(lambda{|env|
+      @store = env['rack.request.cookie_hash']
+      app.call(env) if app
+      [200,{},[]]
+    }, @options || {}, &@block))
+  end
+
+  def get(cookies = {}, &block)
+    app(&block)
+    @response = backend.get('/','HTTP_COOKIE' => Rack::Utils.build_query(cookies))
+  end
+
+  it 'should be able to read a simple key' do
+    get 'key' => 'value' do
+      expect( @store['key'] ).to eql('value')
+    end
+  end
+
+  it 'should be able to set a simple key' do
+    get do
+      @store['key'] = 'value'
+    end
+    expect( @response['Set-Cookie'] ).to eql('key=value')
+  end
+
+  it 'should be able to remove a simple key' do
+    get 'key' => 'value' do
+      @store.delete('key')
+    end
+    expect( @response['Set-Cookie'] ).to eql('key=; expires=Thu, 01-Jan-1970 00:00:00 GMT')
+  end
+
+  it 'should accept a config block' do
+    config do
+      use :Transformer, :key => :prefix, :prefix => 'juno.'
+      adapter :Cookie
+    end
+    get 'juno.key' => 'right', 'key' => 'wrong' do
+      expect( @store['key'] ).to eql('right')
+    end
+  end
+
+  it 'should accept a :domain option' do
+    config :domain => 'example.com'
+    get do
+      @store['key'] = 'value'
+    end
+    expect(@response['Set-Cookie']).to eql('key=value; domain=example.com')
+  end
+
+  it 'should accept a :path option' do
+    config :path => '/path'
+    get do
+      @store['key'] = 'value'
+    end
+    expect(@response['Set-Cookie']).to eql('key=value; path=/path')
+  end
+
+  it 'should be accessible via Rack::Request' do
+    get 'key' => 'value' do |env|
+      req = Rack::Request.new(env)
+      expect(req.cookies['key']).to eql('value')
+    end
+  end
+
+end

metadata

@@ -1,23 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: juno
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
   prerelease: 
 platform: ruby
 authors:
 - Daniel Mendler
-- Yehuda Katz
-- Derek Kastner
+- Hannes Georg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-12 00:00:00.000000000 Z
+date: 2012-12-15 00:00:00.000000000 Z
 dependencies: []
 description: A unified interface to key/value stores (moneta replacement)
 email:
 - mail@daniel-mendler.de
-- wycats@gmail.com
-- dkastner@gmail.com
+- hannes.georg@googlemail.com
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -37,6 +35,7 @@ files:
 - lib/juno.rb
 - lib/juno/adapters/activerecord.rb
 - lib/juno/adapters/cassandra.rb
+- lib/juno/adapters/cookie.rb
 - lib/juno/adapters/couch.rb
 - lib/juno/adapters/datamapper.rb
 - lib/juno/adapters/dbm.rb
@@ -70,11 +69,13 @@ files:
 - lib/juno/transformer.rb
 - lib/juno/version.rb
 - lib/rack/cache/juno.rb
+- lib/rack/juno_cookies.rb
 - lib/rack/session/juno.rb
 - spec/generate.rb
 - spec/helper.rb
 - spec/juno/adapter_activerecord_spec.rb
 - spec/juno/adapter_cassandra_spec.rb
+- spec/juno/adapter_cookie_spec.rb
 - spec/juno/adapter_couch_spec.rb
 - spec/juno/adapter_datamapper_spec.rb
 - spec/juno/adapter_dbm_spec.rb
@@ -185,6 +186,7 @@ files:
 - spec/juno/transformer_zlib_spec.rb
 - spec/junospecs.rb
 - spec/rack/cache_juno_spec.rb
+- spec/rack/juno_cookies_spec.rb
 - spec/rack/session_juno_spec.rb
 homepage: http://github.com/minad/juno
 licenses: []
@@ -216,6 +218,7 @@ test_files:
 - spec/helper.rb
 - spec/juno/adapter_activerecord_spec.rb
 - spec/juno/adapter_cassandra_spec.rb
+- spec/juno/adapter_cookie_spec.rb
 - spec/juno/adapter_couch_spec.rb
 - spec/juno/adapter_datamapper_spec.rb
 - spec/juno/adapter_dbm_spec.rb
@@ -326,4 +329,5 @@ test_files:
 - spec/juno/transformer_zlib_spec.rb
 - spec/junospecs.rb
 - spec/rack/cache_juno_spec.rb
+- spec/rack/juno_cookies_spec.rb
 - spec/rack/session_juno_spec.rb