http-cookie 1.0.0.pre2 → 1.0.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 653d322460f46234180a90aed35776cd7cd8de38
-  data.tar.gz: 14c9c551e73f83be713b128d4ae0a0cd0211d9f0
+  metadata.gz: 38b7c03ef15bbe6b866f7128b719962c7776fa16
+  data.tar.gz: 79078f90e4250e68ec2fa0b6250ee378d7681aea
 SHA512:
-  metadata.gz: 528f89eca80703fec30058de9b9772fc0fb83962d6aa17fe07977b8cbb109fe62f63989097520d955f8b70576bc63ea0c3815195d2d6717bfe1d46a87257cfe4
-  data.tar.gz: 4bf6f20da6f6dc7bfe5ec5980c7298f70c1ebc39024abad55b47d8c9b897d5dfc73f2a4216324ac0e6d884f930e6b401e57cefde0666dc2f88079d0508348b79
+  metadata.gz: 41d93c054cda8e2fbb07554de72061fcf6218da13dce541fda0581056315b0d0438307c1f95043d59bce7742e4cee08ea9295f75c7fc1ddf297849cf7ed87ee0
+  data.tar.gz: a9cebb93040062c160bccf8758a25898af16f8b8fc2e5118a5cfb7210ba96b2f212b8154ca2b4e1fb1e2e740a5efaffd515bd9addc0ddee3be94d6e93e89f7f9

data/http-cookie.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |gem|
   gem.extra_rdoc_files = ['README.md', 'LICENSE.txt']
 
   gem.add_runtime_dependency("domain_name", ["~> 0.5"])
+  gem.add_runtime_dependency("sqlite3", ["~> 1.3.3"])
   gem.add_development_dependency("bundler", [">= 1.2.0"])
   gem.add_development_dependency("test-unit", [">= 2.4.3"])
   gem.add_development_dependency("rake", [">= 0.9.2.2"])

data/lib/http/cookie.rb

@@ -386,6 +386,12 @@ class HTTP::Cookie
     @domain = @domain_name.hostname
   end
 
+  # Returns the domain, with a dot prefixed only if the domain flag is
+  # on.
+  def dot_domain
+    @for_domain ? '.' << @domain : @domain
+  end
+
   # Returns the domain attribute value as a DomainName object.
   attr_reader :domain_name
 

data/lib/http/cookie/version.rb

@@ -1,5 +1,5 @@
 module HTTP
   class Cookie
-    VERSION = "1.0.0.pre2"
+    VERSION = "1.0.0.pre3"
   end
 end

data/lib/http/cookie_jar.rb

@@ -13,6 +13,8 @@ class HTTP::CookieJar
   # Generates a new cookie jar.  The default store class is `:hash`,
   # which maps to `HTTP::CookieJar::HashStore`.  Any given options are
   # passed through to the initializer of the specified store class.
+  # For example, the `:mozilla` (`HTTP::CookieJar::MozillaStore`)
+  # store class requires a `:filename` option.
   def initialize(store = :hash, options = nil)
     case store
     when Symbol
@@ -95,9 +97,6 @@ class HTTP::CookieJar
     if uri
       uri = URI(uri)
       return self unless URI::HTTP === uri && uri.host
-      block = proc { |cookie|
-        yield cookie if cookie.valid_for_uri?(uri)
-      }
     end
 
     @store.each(uri, &block)

data/lib/http/cookie_jar/cookiestxt_saver.rb

@@ -28,11 +28,14 @@ class HTTP::CookieJar::CookiestxtSaver < HTTP::CookieJar::AbstractSaver
     }
   end
 
+  HTTPONLY_PREFIX = '#HttpOnly_'
+  RE_HTTPONLY_PREFIX = /\A#{HTTPONLY_PREFIX}/
+
   # Serializes the cookie into a cookies.txt line.
   def cookie_to_record(cookie)
     cookie.instance_eval {
       [
-        @domain,
+        @httponly ? HTTPONLY_PREFIX + dot_domain : dot_domain,
         @for_domain ? True : False,
         @path,
         @secure ? True : False,
@@ -46,7 +49,15 @@ class HTTP::CookieJar::CookiestxtSaver < HTTP::CookieJar::AbstractSaver
   # Parses a line from cookies.txt and returns a cookie object if the
   # line represents a cookie record or returns nil otherwise.
   def parse_record(line)
-    return nil if line.match(/^#/)
+    case line
+    when RE_HTTPONLY_PREFIX
+      httponly = true
+      line = $'
+    when /\A#/
+      return nil
+    else
+      httponly = false
+    end
 
     domain,
     s_for_domain,	# Whether this cookie is for domain
@@ -68,6 +79,7 @@ class HTTP::CookieJar::CookiestxtSaver < HTTP::CookieJar::AbstractSaver
       :for_domain => s_for_domain == True,
       :path => path,
       :secure => s_secure == True,
+      :httponly => httponly,
       :expires => expires,
       :version => 0)
   end

data/lib/http/cookie_jar/hash_store.rb

@@ -9,11 +9,12 @@ end
 # :startdoc:
 
 class HTTP::CookieJar
+  # A store class that uses a hash of hashes.
   class HashStore < AbstractStore
-    GC_THRESHOLD = HTTP::Cookie::MAX_COOKIES_TOTAL / 20
-
     def default_options
-      {}
+      {
+        :gc_threshold => HTTP::Cookie::MAX_COOKIES_TOTAL / 20
+      }
     end
 
     def initialize(options = nil)
@@ -40,18 +41,20 @@ class HTTP::CookieJar
 
     def add(cookie)
       path_cookies = ((@jar[cookie.domain_name.hostname] ||= {})[cookie.path] ||= {})
+      path_cookies[cookie.name] = cookie
+      cleanup if (@gc_index += 1) >= @gc_threshold
+      self
+    end
 
-      if cookie.expired?
-        path_cookies.delete(cookie.name)
-      else
-        path_cookies[cookie.name] = cookie
-        cleanup if (@gc_index += 1) >= GC_THRESHOLD
-      end
-
+    def delete(cookie)
+      path_cookies = ((@jar[cookie.domain_name.hostname] ||= {})[cookie.path] ||= {})
+      path_cookies.delete(cookie.name)
       self
     end
+    private :delete
 
     def each(uri = nil)
+      now = Time.now
       if uri
         thost = DomainName.new(uri.host)
         tpath = uri.path
@@ -60,11 +63,13 @@ class HTTP::CookieJar
           paths.each { |path, hash|
             next unless HTTP::Cookie.path_match?(path, tpath)
             hash.delete_if { |name, cookie|
-              if cookie.expired?
+              if cookie.expired?(now)
                 true
               else
-                cookie.accessed_at = Time.now
-                yield cookie
+                if cookie.valid_for_uri?(uri)
+                  cookie.accessed_at = now
+                  yield cookie
+                end
                 false
               end
             }
@@ -74,7 +79,7 @@ class HTTP::CookieJar
         @jar.each { |domain, paths|
           paths.each { |path, hash|
             hash.delete_if { |name, cookie|
-              if cookie.expired?
+              if cookie.expired?(now)
                 true
               else
                 yield cookie
@@ -97,14 +102,14 @@ class HTTP::CookieJar
     end
 
     def cleanup(session = false)
+      now = Time.now
       all_cookies = []
-
       @jar.each { |domain, paths|
         domain_cookies = []
 
         paths.each { |path, hash|
           hash.delete_if { |name, cookie|
-            if cookie.expired? || (session && cookie.session?)
+            if cookie.expired?(now) || (session && cookie.session?)
               true
             else
               domain_cookies << cookie
@@ -116,7 +121,7 @@ class HTTP::CookieJar
         if (debt = domain_cookies.size - HTTP::Cookie::MAX_COOKIES_PER_DOMAIN) > 0
           domain_cookies.sort_by!(&:created_at)
           domain_cookies.slice!(0, debt).each { |cookie|
-            add(cookie.expire!)
+            delete(cookie)
           }
         end
 
@@ -126,7 +131,7 @@ class HTTP::CookieJar
       if (debt = all_cookies.size - HTTP::Cookie::MAX_COOKIES_TOTAL) > 0
         all_cookies.sort_by!(&:created_at)
         all_cookies.slice!(0, debt).each { |cookie|
-          add(cookie.expire!)
+          delete(cookie)
         }
       end
 

data/lib/http/cookie_jar/mozilla_store.rb

@@ -0,0 +1,327 @@
+require 'http/cookie_jar'
+require 'sqlite3'
+
+class HTTP::CookieJar
+  class MozillaStore < AbstractStore
+    SCHEMA_VERSION = 5
+
+    def default_options
+      {
+        :gc_threshold => HTTP::Cookie::MAX_COOKIES_TOTAL / 20,
+        :app_id => 0,
+        :in_browser_element => false,
+      }
+    end
+
+    ALL_COLUMNS = %w[
+      baseDomain
+      appId inBrowserElement
+      name value
+      host path
+      expiry creationTime lastAccessed
+      isSecure isHttpOnly
+    ]
+    UK_COLUMNS = %w[
+      name host path
+      appId inBrowserElement
+    ]
+
+    def initialize(options = nil)
+      super
+
+      @filename = options[:filename] or raise ArgumentError, ':filename option is missing'
+
+      @db = SQLite3::Database.new(@filename)
+      @db.results_as_hash = true
+
+      upgrade_database
+
+      @gc_index = 0
+    end
+
+    def schema_version
+      @schema_version ||= @db.execute("PRAGMA user_version").first[0]
+    rescue SQLite3::SQLException
+      @logger.warn "couldn't get schema version!" if @logger
+      return nil
+    end
+
+    protected
+
+    def schema_version=(version)
+      @db.execute("PRAGMA user_version = %d" % version)
+      @schema_version = version
+    end
+
+    def create_table
+      self.schema_version = SCHEMA_VERSION
+      @db.execute("DROP TABLE IF EXISTS moz_cookies")
+      @db.execute(<<-'SQL')
+                   CREATE TABLE moz_cookies (
+                     id INTEGER PRIMARY KEY,
+                     baseDomain TEXT,
+                     appId INTEGER DEFAULT 0,
+                     inBrowserElement INTEGER DEFAULT 0,
+                     name TEXT,
+                     value TEXT,
+                     host TEXT,
+                     path TEXT,
+                     expiry INTEGER,
+                     lastAccessed INTEGER,
+                     creationTime INTEGER,
+                     isSecure INTEGER,
+                     isHttpOnly INTEGER,
+                     CONSTRAINT moz_uniqueid UNIQUE (name, host, path, appId, inBrowserElement)
+                   )
+      SQL
+      @db.execute(<<-'SQL')
+                   CREATE INDEX moz_basedomain
+                     ON moz_cookies (baseDomain,
+                                     appId,
+                                     inBrowserElement);
+      SQL
+    end
+
+    def upgrade_database
+      loop {
+        case schema_version
+        when nil, 0
+          self.schema_version = SCHEMA_VERSION
+          break
+        when 1
+          @db.execute("ALTER TABLE moz_cookies ADD lastAccessed INTEGER")
+          self.schema_version += 1
+        when 2
+          @db.execute("ALTER TABLE moz_cookies ADD baseDomain TEXT")
+
+          st_update = @db.prepare("UPDATE moz_cookies SET baseDomain = :baseDomain WHERE id = :id")
+
+          @db.execute("SELECT id, host FROM moz_cookies") { |row|
+            domain = DomainName.new(row[:host]).domain
+            st_update.execute(:baseDomain => domain, :id => row[:id])
+          }
+
+          @db.execute("CREATE INDEX moz_basedomain ON moz_cookies (baseDomain)")
+          self.schema_version += 1
+        when 3
+          st_delete = @db.prepare("DELETE FROM moz_cookies WHERE id = :id")
+
+          prev_row  = nil
+          @db.execute(<<-'SQL') { |row|
+                       SELECT id, name, host, path FROM moz_cookies
+                         ORDER BY name ASC, host ASC, path ASC, expiry ASC
+          SQL
+            if %w[name host path].all? { |col| row[col] == prev_row[col] }
+              st_delete.execute(prev_row['id'])
+            end
+            prev_row = row
+          }
+
+          @db.execute("ALTER TABLE moz_cookies ADD creationTime INTEGER")
+          @db.execute("UPDATE moz_cookies SET creationTime = (SELECT id WHERE id = moz_cookies.id)")
+          @db.execute("CREATE UNIQUE INDEX moz_uniqueid ON moz_cookies (name, host, path)")
+          self.schema_version += 1
+        when 4
+          @db.execute("ALTER TABLE moz_cookies RENAME TO moz_cookies_old")
+          @db.execute("DROP INDEX moz_basedomain")
+          create_table
+          @db.execute(<<-'SQL')
+                       INSERT INTO moz_cookies
+                         (baseDomain, appId, inBrowserElement, name, value, host, path, expiry,
+                          lastAccessed, creationTime, isSecure, isHttpOnly)
+                         SELECT baseDomain, 0, 0, name, value, host, path, expiry,
+                                lastAccessed, creationTime, isSecure, isHttpOnly
+                           FROM moz_cookies_old
+          SQL
+          @db.execute("DROP TABLE moz_cookies_old")
+          @logger.info("Upgraded database to schema version %d" % schema_version) if @logger
+        else
+          break
+        end
+      }
+
+      begin
+        @db.execute("SELECT %s from moz_cookies limit 1" % ALL_COLUMNS.join(', '))
+      rescue SQLite3::SQLException
+        create_table
+      end
+    end
+
+    public
+
+    def add(cookie)
+      @st_add ||=
+        @db.prepare('INSERT OR REPLACE INTO moz_cookies (%s) VALUES (%s)' % [
+          ALL_COLUMNS.join(', '),
+          ALL_COLUMNS.map { |col| ":#{col}" }.join(', ')
+        ])
+
+      @st_add.execute({
+          :baseDomain => cookie.domain_name.domain,
+          :appId => @app_id,
+          :inBrowserElement => @in_browser_element ? 1 : 0,
+          :name => cookie.name, :value => cookie.value,
+          :host => cookie.dot_domain,
+          :path => cookie.path,
+          :expiry => cookie.expires_at.to_i,
+          :creationTime => cookie.created_at.to_i,
+          :lastAccessed => cookie.accessed_at.to_i,
+          :isSecure => cookie.secure? ? 1 : 0,
+          :isHttpOnly => cookie.httponly? ? 1 : 0,
+        })
+      cleanup if (@gc_index += 1) >= @gc_threshold
+
+      self
+    end
+
+    def each(uri = nil)
+      now = Time.now
+      if uri
+        @st_cookies_for_domain ||=
+          @db.prepare(<<-'SQL')
+                       SELECT * FROM moz_cookies
+                         WHERE baseDomain = :baseDomain AND
+                               appId = :appId AND
+                               inBrowserElement = :inBrowserElement AND
+                               expiry >= :expiry
+                      SQL
+
+        @st_update_lastaccessed ||=
+            @db.prepare("UPDATE moz_cookies SET lastAccessed = :lastAccessed where id = :id")
+
+        thost = DomainName.new(uri.host)
+        tpath = HTTP::Cookie.normalize_path(uri.path)
+
+        @st_cookies_for_domain.execute({
+            :baseDomain => thost.domain_name.domain,
+            :appId => @app_id,
+            :inBrowserElement => @in_browser_element ? 1 : 0,
+            :expiry => now.to_i,
+          }).each { |row|
+          if secure = row['isSecure'] != 0
+            next unless URI::HTTPS === uri
+          end
+
+          cookie = HTTP::Cookie.new({}.tap { |attrs|
+              attrs[:name]        = row['name']
+              attrs[:value]       = row['value']
+              attrs[:domain]      = row['host']
+              attrs[:path]        = row['path']
+              attrs[:expires_at]  = Time.at(row['expiry'])
+              attrs[:accessed_at] = Time.at(row['lastAccessed'])
+              attrs[:created_at]  = Time.at(row['creationTime'])
+              attrs[:secure]      = secure
+              attrs[:httponly]    = row['isHttpOnly'] != 0
+            })
+
+          if cookie.valid_for_uri?(uri)
+            cookie.accessed_at = now
+            @st_update_lastaccessed.execute({
+                'lastAccessed' => now.to_i,
+                'id' => row['id'],
+              })
+            yield cookie
+          end
+        }
+      else
+        @st_all_cookies ||=
+          @db.prepare(<<-'SQL')
+                       SELECT * FROM moz_cookies
+                         WHERE appId = :appId AND
+                               inBrowserElement = :inBrowserElement AND
+                               expiry >= :expiry
+                      SQL
+
+        @st_all_cookies.execute({
+            :appId => @app_id,
+            :inBrowserElement => @in_browser_element ? 1 : 0,
+            :expiry => now.to_i,
+          }).each { |row|
+          cookie = HTTP::Cookie.new({}.tap { |attrs|
+              attrs[:name]        = row['name']
+              attrs[:value]       = row['value']
+              attrs[:domain]      = row['host']
+              attrs[:path]        = row['path']
+              attrs[:expires_at]  = Time.at(row['expiry'])
+              attrs[:accessed_at] = Time.at(row['lastAccessed'])
+              attrs[:created_at]  = Time.at(row['creationTime'])
+              attrs[:secure]      = row['isSecure'] != 0
+              attrs[:httponly]    = row['isHttpOnly'] != 0
+            })
+
+          yield cookie
+        }
+      end
+      self
+    end
+
+    def clear
+      @db.execute("DELETE FROM moz_cookies")
+      self
+    end
+
+    def count
+      @st_count ||=
+        @db.prepare("SELECT COUNT(id) FROM moz_cookies")
+
+      @st_count.execute.first[0]
+    end
+    protected :count
+
+    def empty?
+      count == 0
+    end
+
+    def cleanup(session = false)
+      now = Time.now
+      all_cookies = []
+
+      @st_delete_expired ||=
+        @db.prepare("DELETE FROM moz_cookies WHERE expiry < :expiry")
+
+      @st_overusing_domains ||=
+        @db.prepare(<<-'SQL')
+                     SELECT LTRIM(host, '.') domain, COUNT(*) count
+                       FROM moz_cookies
+                       GROUP BY domain
+                       HAVING count > :count
+                    SQL
+
+      @st_delete_per_domain_overuse ||=
+        @db.prepare(<<-'SQL')
+                     DELETE FROM moz_cookies WHERE id IN (
+                       SELECT id FROM moz_cookies
+                         WHERE LTRIM(host, '.') = :domain
+                         ORDER BY creationtime
+                         LIMIT :limit)
+        SQL
+      @st_delete_total_overuse ||=
+        @db.prepare(<<-'SQL')
+                     DELETE FROM moz_cookies WHERE id IN (
+                       SELECT id FROM moz_cookies ORDER BY creationTime ASC LIMIT :limit
+                     )
+        SQL
+
+      @st_delete_expired.execute({ 'expiry' => now.to_i })
+
+      @st_overusing_domains.execute({
+          'count' => HTTP::Cookie::MAX_COOKIES_PER_DOMAIN
+        }).each { |row|
+        domain, count = row['domain'], row['count']
+
+        @st_delete_per_domain_overuse.execute({
+            'domain' => domain,
+            'limit' => count - HTTP::Cookie::MAX_COOKIES_PER_DOMAIN,
+          })
+      }
+
+      overrun = count - HTTP::Cookie::MAX_COOKIES_TOTAL
+
+      if overrun > 0
+        @st_delete_total_overuse.execute({ 'limit' => overrun })
+      end
+
+      @gc_index = 0
+    end
+  end
+end

data/test/test_http_cookie.rb

@@ -162,6 +162,7 @@ class TestHTTPCookie < Test::Unit::TestCase
 
     assert_equal 'example.com', cookie.domain
     assert cookie.for_domain?
+    assert_equal '.example.com', cookie.dot_domain
   end
 
   def test_parse_domain_no_dot
@@ -173,6 +174,7 @@ class TestHTTPCookie < Test::Unit::TestCase
 
     assert_equal 'example.com', cookie.domain
     assert cookie.for_domain?
+    assert_equal '.example.com', cookie.dot_domain
   end
 
   def test_parse_domain_none
@@ -184,6 +186,7 @@ class TestHTTPCookie < Test::Unit::TestCase
 
     assert_equal 'example.com', cookie.domain
     assert !cookie.for_domain?
+    assert_equal 'example.com', cookie.dot_domain
   end
 
   def test_parse_max_age

data/test/test_http_cookie_jar.rb

@@ -360,20 +360,31 @@ class TestHTTPCookieJar < Test::Unit::TestCase
                                              :value => 'Foo#Baz',
                                              :path => '/foo/',
                                              :for_domain => false))
+    h_cookie = HTTP::Cookie.new(cookie_values(:name => 'Quux',
+                                              :value => 'Foo#Quux',
+                                              :httponly => true))
 
     @jar.add(cookie)
     @jar.add(s_cookie)
     @jar.add(cookie2)
+    @jar.add(h_cookie)
 
-    assert_equal(3, @jar.cookies(url).length)
+    assert_equal(4, @jar.cookies(url).length)
 
     Dir.mktmpdir do |dir|
-      @jar.save(File.join(dir, "cookies.txt"), :cookiestxt)
+      filename = File.join(dir, "cookies.txt")
+      @jar.save(filename, :cookiestxt)
+
+      content = File.read(filename)
+
+      assert_match(/^\.rubyforge\.org\t.*\tFoo\t/, content)
+      assert_match(/^rubyforge\.org\t.*\tBaz\t/, content)
+      assert_match(/^#HttpOnly_\.rubyforge\.org\t/, content)
 
       jar = HTTP::CookieJar.new
-      jar.load(File.join(dir, "cookies.txt"), :cookiestxt) # HACK test the format
+      jar.load(filename, :cookiestxt) # HACK test the format
       cookies = jar.cookies(url)
-      assert_equal(2, cookies.length)
+      assert_equal(3, cookies.length)
       cookies.each { |cookie|
         case cookie.name
         when 'Foo'
@@ -382,18 +393,27 @@ class TestHTTPCookieJar < Test::Unit::TestCase
           assert_equal 'rubyforge.org', cookie.domain
           assert_equal true, cookie.for_domain
           assert_equal '/', cookie.path
+          assert_equal false, cookie.httponly?
         when 'Baz'
           assert_equal 'Foo#Baz', cookie.value
           assert_equal 'rubyforge.org', cookie.domain
           assert_equal false, cookie.for_domain
           assert_equal '/foo/', cookie.path
+          assert_equal false, cookie.httponly?
+        when 'Quux'
+          assert_equal 'Foo#Quux', cookie.value
+          assert_equal expires, cookie.expires
+          assert_equal 'rubyforge.org', cookie.domain
+          assert_equal true, cookie.for_domain
+          assert_equal '/', cookie.path
+          assert_equal true, cookie.httponly?
         else
           raise
         end
       }
     end
 
-    assert_equal(3, @jar.cookies(url).length)
+    assert_equal(4, @jar.cookies(url).length)
   end
 
   def test_expire_cookies
@@ -514,8 +534,7 @@ class TestHTTPCookieJar < Test::Unit::TestCase
     assert_equal('Foo1 Foo2', @jar.cookies(surl).map { |c| c.name }.sort.join(' ') )
   end
 
-  def test_max_cookies
-    jar = HTTP::CookieJar.new
+  def h_test_max_cookies(jar, slimit)
     limit_per_domain = HTTP::Cookie::MAX_COOKIES_PER_DOMAIN
     uri = URI('http://www.example.org/')
     date = Time.at(Time.now.to_i + 86400)
@@ -540,7 +559,6 @@ class TestHTTPCookieJar < Test::Unit::TestCase
     }.sort
 
     hlimit = HTTP::Cookie::MAX_COOKIES_TOTAL
-    slimit = hlimit + HTTP::CookieJar::HashStore::GC_THRESHOLD
 
     n = hlimit / limit_per_domain * 2
 
@@ -569,4 +587,23 @@ class TestHTTPCookieJar < Test::Unit::TestCase
       cookie.domain == cookie.value
     }
   end
+
+  def test_max_cookies_hashstore
+    gc_threshold = 150
+    h_test_max_cookies(
+      HTTP::CookieJar.new(:hash,
+        :gc_threshold => gc_threshold),
+      HTTP::Cookie::MAX_COOKIES_TOTAL + gc_threshold)
+  end
+
+  def test_max_cookies_mozillastore
+    gc_threshold = 150
+    Dir.mktmpdir { |dir|
+      h_test_max_cookies(
+        HTTP::CookieJar.new(:mozilla,
+          :gc_threshold => gc_threshold,
+          :filename => File.join(dir, "cookies.sqlite")),
+        HTTP::Cookie::MAX_COOKIES_TOTAL + gc_threshold)
+    }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http-cookie
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre2
+  version: 1.0.0.pre3
 platform: ruby
 authors:
 - Akinori MUSHA
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-22 00:00:00.000000000 Z
+date: 2013-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: domain_name
@@ -27,6 +27,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -125,6 +139,7 @@ files:
 - lib/http/cookie_jar/abstract_store.rb
 - lib/http/cookie_jar/cookiestxt_saver.rb
 - lib/http/cookie_jar/hash_store.rb
+- lib/http/cookie_jar/mozilla_store.rb
 - lib/http/cookie_jar/yaml_saver.rb
 - test/helper.rb
 - test/simplecov_start.rb