dwaite-cookiejar 0.1.3 → 0.2.0

data/lib/cookiejar/jar.rb

@@ -1,46 +1,46 @@
 require 'cookiejar/cookie'
-
-# A cookie store for client side usage. 
-# - Enforces cookie validity rules
-# - Returns just the cookies valid for a given URI
-# - Handles expiration of cookies
-# - Allows for persistence of cookie data (with or without sessoin) 
-#
-#--
-# Internal format:
-# 
-# Internally, the data structure is a set of nested hashes.
-# Domain Level:
-# At the domain level, the hashes are of individual domains,
-# down-cased and without any leading period. For instance, imagine cookies
-# for .foo.com, .bar.com, and .auth.bar.com:
-#
-# { 
-#   "foo.com"      : <host data>,
-#   "bar.com"      : <host data>,
-#   "auth.bar.com" : <host data>
-# }
-# Lookups are done both for the matching entry, and for an entry without
-# the first segment up to the dot, ie. for /^\.?[^\.]+\.(.*)$/.
-# A lookup of auth.bar.com would match both bar.com and 
-# auth.bar.com, but not entries for com or www.auth.bar.com.
-#
-# Host Level:
-# Entries are in an hash, with keys of the path and values of a hash of
-# cookie names to cookie object
-#
-# {
-#   "/" : {"session" : <Cookie>, "cart_id" : <Cookie>}
-#   "/protected" : {"authentication" : <Cookie>}
-# }
-#
-# Paths are given a straight prefix string comparison to match.
-# Further filters <secure, http only, ports> are not represented in this
-# heirarchy. 
-#
-# Cookies returned are ordered solely by specificity (length) of the
-# path. 
+ 
 module CookieJar
+  # A cookie store for client side usage. 
+  # - Enforces cookie validity rules
+  # - Returns just the cookies valid for a given URI
+  # - Handles expiration of cookies
+  # - Allows for persistence of cookie data (with or without session) 
+  #
+  #--
+  # Internal format:
+  # 
+  # Internally, the data structure is a set of nested hashes.
+  # Domain Level:
+  # At the domain level, the hashes are of individual domains,
+  # down-cased and without any leading period. For instance, imagine cookies
+  # for .foo.com, .bar.com, and .auth.bar.com:
+  #
+  # { 
+  #   "foo.com"      : <host data>,
+  #   "bar.com"      : <host data>,
+  #   "auth.bar.com" : <host data>
+  # }
+  # Lookups are done both for the matching entry, and for an entry without
+  # the first segment up to the dot, ie. for /^\.?[^\.]+\.(.*)$/.
+  # A lookup of auth.bar.com would match both bar.com and 
+  # auth.bar.com, but not entries for com or www.auth.bar.com.
+  #
+  # Host Level:
+  # Entries are in an hash, with keys of the path and values of a hash of
+  # cookie names to cookie object
+  #
+  # {
+  #   "/" : {"session" : <Cookie>, "cart_id" : <Cookie>}
+  #   "/protected" : {"authentication" : <Cookie>}
+  # }
+  #
+  # Paths are given a straight prefix string comparison to match.
+  # Further filters <secure, http only, ports> are not represented in this
+  # heirarchy. 
+  #
+  # Cookies returned are ordered solely by specificity (length) of the
+  # path.
   class Jar
     def initialize
   	  @domains = {}
@@ -49,13 +49,71 @@ module CookieJar
     # Given a request URI and a literal Set-Cookie header value, attempt to
     # add the cookie to the cookie store.
     # 
-    # returns the Cookie object on success, otherwise raises an 
+    # Returns the Cookie object on success, otherwise raises an 
     # InvalidCookieError
     def set_cookie request_uri, cookie_header_value
     	cookie = Cookie.from_set_cookie request_uri, cookie_header_value
-  	  domain_paths = find_or_add_domain_for_cookie cookie
-  	  add_cookie_to_path(domain_paths,cookie)
+    	add_cookie cookie
+    end
+    
+    # Add a pre-existing cookie object to the jar.
+    def add_cookie cookie
+      domain_paths = find_or_add_domain_for_cookie cookie
+  	  add_cookie_to_path domain_paths, cookie
   	  cookie
+  	end
+  	
+  	# Return an array of all cookie objects in the jar
+  	def to_a
+  	  result = []
+  	  @domains.values.each do |paths|
+  	    paths.values.each do |cookies|
+  	      cookies.values.inject result, :<<
+	      end
+      end
+      result
+	  end
+	  
+	  def to_json *a
+	    {
+	      'json_class' => self.class.name,
+	      'cookies' => (to_a.to_json *a)
+      }.to_json *a
+    end
+    
+    # Create a new Jar from a JSON-backed hash.
+    def self.json_create o
+      if o.is_a? Hash
+        o = o['cookies']
+      end
+      cookies = o.inject [] do |result, cookie_json|
+        result << (Cookie.json_create cookie_json)
+      end
+      self.from_a cookies
+    end
+    
+    # Create a new Jar from an array of Cookie objects
+    def self.from_a cookies
+      jar = new
+      cookies.each do |cookie|
+        jar.add_cookie cookie
+      end
+      jar
+    end
+
+    # Look through the jar for any cookies which have passed their expiration
+    # date. Optionally, you can pass true to expire any session cookies as
+    # well
+    def expire_cookies session = false
+      @domains.delete_if do |domain, paths|
+        paths.delete_if do |path, cookies|
+          cookies.delete_if do |cookie_name, cookie|
+            cookie.is_expired? || (session && cookie.is_session?)
+          end
+          cookies.empty?
+        end
+        paths.empty?
+      end
     end
     
     # Given a request URI, return a sorted list of Cookie objects. Cookies
@@ -64,8 +122,8 @@ module CookieJar
     #
     # optional arguments are 
     # - :script - if set, cookies set to be HTTP-only will be ignored
-    def get_cookies request_uri, args = {}
-  	  uri = request_uri.is_a?(URI)? request_uri : URI.parse(request_uri)
+    def get_cookies request_uri, args = { }
+  	  uri = to_uri request_uri
     	hosts = Cookie.compute_search_domains uri
 	
     	results = []
@@ -73,11 +131,9 @@ module CookieJar
     	  domain = find_domain host
     	  domain.each do |path, cookies|
     		  if uri.path.start_with? path
-      		  results += cookies.select do |name, cookie|
+      		  results += cookies.values.select do |cookie|
         			cookie.should_send? uri, args[:script]
-        		end.collect do |name, cookie|
-        			cookie
-        		end            
+        		end
         	end
       	end
       end
@@ -87,21 +143,28 @@ module CookieJar
     	end
     end
     
-    # Given a request URI, return a sorted array of Cookie headers, in the 
-    # format ['Cookie', '<Header Value>']. Cookies will be in order per 
-    # RFC 2965 - sorted by longest path length, but otherwise unordered.
+    # Given a request URI, return a string Cookie header.Cookies will be in
+    # order per RFC 2965 - sorted by longest path length, but otherwise
+    # unordered.
     #
     # optional arguments are 
     # - :script - if set, cookies set to be HTTP-only will be ignored    
-    def get_cookie_headers request_uri, args = {}
+    def get_cookie_header request_uri, args = { }
     	cookies = get_cookies request_uri, args
     	cookies.map do |cookie|
-    	  ['Cookie', "#{cookie.name}=#{cookie.value}"]
-    	end
+    	  cookie.to_s
+  	  end.join ";"
     end
 
+    # Given a request URI, return a string containing the value of a possible
+    # Cookie header. Cookies will be in order per RFC 2965 - sorted by
+    # longest path length, but otherwise unordered.
   protected  
 
+    def to_uri request_uri
+      (request_uri.is_a? URI)? request_uri : (URI.parse request_uri)
+    end
+    
     def find_domain host
     	@domains[host] || {}
     end
@@ -110,7 +173,7 @@ module CookieJar
     	@domains[cookie.domain] ||= {}
     end
 	
-    def add_cookie_to_path (paths, cookie)
+    def add_cookie_to_path paths, cookie
     	path_entry = (paths[cookie.path] ||= {})
     	path_entry[cookie.name] = cookie
     end

data/test/cookie_test.rb

@@ -1,4 +1,5 @@
 require 'cookiejar'
+require 'rubygems'
 
 include CookieJar
 
@@ -43,233 +44,32 @@ describe Cookie do
       cookie.secure.should be_true
     end
   end
-  describe '.validate_cookie' do
-    localaddr = 'http://localhost/foo/bar/'
-    it "should fail if version unset" do
-      lambda do
-        unversioned = Cookie.from_set_cookie localaddr, 'foo=bar'
-        unversioned.instance_variable_set :@version, nil
-        Cookie.validate_cookie localaddr, unversioned
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail if the path is more specific" do
-      lambda do
-        subdirred = Cookie.from_set_cookie localaddr, 'foo=bar;path=/foo/bar/baz'
-        # validate_cookie localaddr, subdirred
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail if the path is different than the request" do
-      lambda do
-        difdirred = Cookie.from_set_cookie localaddr, 'foo=bar;path=/baz/'
-        # validate_cookie localaddr, difdirred
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail if the domain has no dots" do
-      lambda do
-        nodot = Cookie.from_set_cookie 'http://zero/', 'foo=bar;domain=zero'
-        # validate_cookie 'http://zero/', nodot
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail for explicit localhost" do
-      lambda do
-        localhost = Cookie.from_set_cookie localaddr, 'foo=bar;domain=localhost'
-        # validate_cookie localaddr, localhost
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail for mismatched domains" do
-      lambda do
-        foobar = Cookie.from_set_cookie 'http://www.foo.com/', 'foo=bar;domain=bar.com'
-        # validate_cookie 'http://www.foo.com/', foobar
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail for domains more than one level up" do
-      lambda do
-        xyz = Cookie.from_set_cookie 'http://x.y.z.com/', 'foo=bar;domain=z.com'
-        # validate_cookie 'http://x.y.z.com/', xyz
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail for setting subdomain cookies" do
-      lambda do
-        subdomain = Cookie.from_set_cookie 'http://foo.com/', 'foo=bar;domain=auth.foo.com'
-        # validate_cookie 'http://foo.com/', subdomain
-      end.should raise_error InvalidCookieError
-    end
-    it "should handle a normal implicit internet cookie" do
-      normal = Cookie.from_set_cookie 'http://foo.com/', 'foo=bar'
-      Cookie.validate_cookie('http://foo.com/', normal).should be_true
-    end
-    it "should handle a normal implicit localhost cookie" do
-      localhost = Cookie.from_set_cookie 'http://localhost/', 'foo=bar'
-      Cookie.validate_cookie('http://localhost/', localhost).should be_true
-    end
-    it "should handle an implicit IP address cookie" do
-      ipaddr =  Cookie.from_set_cookie 'http://127.0.0.1/', 'foo=bar'
-      Cookie.validate_cookie('http://127.0.0.1/', ipaddr).should be_true
-    end
-    it "should handle an explicit domain on an internet site" do
-      explicit = Cookie.from_set_cookie 'http://foo.com/', 'foo=bar;domain=.foo.com'
-      Cookie.validate_cookie('http://foo.com/', explicit).should be_true
-    end
-    it "should handle setting a cookie explicitly on a superdomain" do
-      superdomain = Cookie.from_set_cookie 'http://auth.foo.com/', 'foo=bar;domain=.foo.com'
-      Cookie.validate_cookie('http://foo.com/', superdomain).should be_true
-    end
-    it "should handle explicitly setting a cookie" do
-      explicit = Cookie.from_set_cookie 'http://foo.com/bar/', 'foo=bar;path=/bar/'
-      Cookie.validate_cookie('http://foo.com/bar/', explicit)
-    end
-    it "should handle setting a cookie on a higher path" do
-      higher = Cookie.from_set_cookie 'http://foo.com/bar/baz/', 'foo=bar;path=/bar/'
-      Cookie.validate_cookie('http://foo.com/bar/baz/', higher)
-    end
-  end
-  describe '.cookie_base_path' do
-    it "should leave '/' alone" do
-      Cookie.cookie_base_path('/').should == '/'
-    end
-    it "should strip off everything after the last '/'" do
-      Cookie.cookie_base_path('/foo/bar/baz').should == '/foo/bar/'
-    end
-    it "should handle query parameters and fragments with slashes" do
-      Cookie.cookie_base_path('/foo/bar?query=a/b/c#fragment/b/c').should == '/foo/'
-    end
-    it "should handle URI objects" do
-      Cookie.cookie_base_path(URI.parse('http://www.foo.com/bar/')).should == '/bar/'
-    end
-    it "should preserve case" do
-      Cookie.cookie_base_path("/BaR/").should == '/BaR/'
-    end
-  end
-  describe '.determine_cookie_path' do
-    it "should use the requested path when none is specified for the cookie" do
-      Cookie.determine_cookie_path('http://foo.com/', nil).should == '/'
-      Cookie.determine_cookie_path('http://foo.com/bar/baz', '').should == '/bar/'
-    end
-    it "should handle URI objects" do
-      Cookie.determine_cookie_path(URI.parse('http://foo.com/bar/'), '').should == '/bar/'
-    end
-    it "should handle Cookie objects" do
-      cookie = Cookie.from_set_cookie('http://foo.com/', "name=value;path=/")
-      Cookie.determine_cookie_path('http://foo.com/', cookie).should == '/'
-    end
-    it "should ignore the request when a path is specified" do
-      Cookie.determine_cookie_path('http://foo.com/ignorable/path', '/path/').should == '/path/'
-    end
-  end
-  describe '.compute_search_domains' do
-    it "should handle subdomains" do
-      Cookie.compute_search_domains('http://www.auth.foo.com/').should ==
-       ['www.auth.foo.com', '.www.auth.foo.com', '.auth.foo.com']
-    end
-    it "should handle root domains" do
-      Cookie.compute_search_domains('http://foo.com/').should ==
-      ['foo.com', '.foo.com']
-    end
-    it "should handle IP addresses" do
-      Cookie.compute_search_domains('http://127.0.0.1/').should ==
-      ['127.0.0.1']
-    end
-    it "should handle local addresses" do
-      Cookie.compute_search_domains('http://zero/').should == 
-      ['zero.local', '.zero.local', '.local']
-    end
-  end
-  describe '.determine_cookie_domain' do
-    it "should add a dot to the front of domains" do
-      Cookie.determine_cookie_domain('http://foo.com/', 'foo.com').should == '.foo.com'
-    end
-    it "should not add a second dot if one present" do
-      Cookie.determine_cookie_domain('http://foo.com/', '.foo.com').should == '.foo.com'
-    end
-    it "should handle Cookie objects" do
-      c = Cookie.from_set_cookie('http://foo.com/', "foo=bar;domain=foo.com")
-      Cookie.determine_cookie_domain('http://foo.com/', c).should == '.foo.com'
-    end
-    it "should handle URI objects" do
-      Cookie.determine_cookie_domain(URI.parse('http://foo.com/'), '.foo.com').should == '.foo.com'
-    end
-    it "should use an exact hostname when no domain specified" do
-      Cookie.determine_cookie_domain('http://foo.com/', '').should == 'foo.com'
-    end
-    it "should leave IPv4 addresses alone" do
-      Cookie.determine_cookie_domain('http://127.0.0.1/', '127.0.0.1').should == '127.0.0.1'
-    end
-    it "should leave IPv6 addresses alone" do
-      ['2001:db8:85a3::8a2e:370:7334', '::ffff:192.0.2.128'].each do |value|
-        Cookie.determine_cookie_domain("http://[#{value}]/", value).should == value
+  begin
+    require 'json'
+    describe ".to_json" do
+      it "should serialize a cookie to JSON" do
+        c = Cookie.from_set_cookie 'https://localhost/', 'foo=bar;secure;expires=Fri, September 11 2009 18:10:00 -0700'
+        json = c.to_json
+        json.should be_a String
       end
     end
-  end
-  describe ".effective_host" do
-    it "should leave proper domains the same" do
-      ['google.com', 'www.google.com', 'google.com.'].each do |value|
-        Cookie.effective_host(value).should == value
+    describe ".json_create" do
+      it "should deserialize JSON to a cookie" do
+        json = "{\"name\":\"foo\",\"value\":\"bar\",\"domain\":\"localhost.local\",\"path\":\"\\/\",\"created_at\":\"2009-09-11 12:51:03 -0600\",\"expiry\":\"2009-09-11 19:10:00 -0600\",\"secure\":true}" 
+        hash = JSON.parse json
+        c = Cookie.json_create hash
+        CookieValidation.validate_cookie 'https://localhost/', c
       end
-    end
-    it "should handle a URI object" do
-      Cookie.effective_host(URI.parse('http://example.com/')).should == 'example.com'
-    end	
-    it "should add a local suffix on unqualified hosts" do
-      Cookie.effective_host('localhost').should == 'localhost.local'
-    end
-    it "should leave IPv4 addresses alone" do
-      Cookie.effective_host('127.0.0.1').should == '127.0.0.1'
-    end
-    it "should leave IPv6 addresses alone" do
-      ['2001:db8:85a3::8a2e:370:7334', ':ffff:192.0.2.128'].each do |value|
-        Cookie.effective_host(value).should == value
+      it "should automatically deserialize to a cookie" do
+        json = "{\"json_class\":\"CookieJar::Cookie\",\"name\":\"foo\",\"value\":\"bar\",\"domain\":\"localhost.local\",\"path\":\"\\/\",\"created_at\":\"2009-09-11 12:51:03 -0600\",\"expiry\":\"2009-09-11 19:10:00 -0600\",\"secure\":true}" 
+        c = JSON.parse json
+        c.should be_a Cookie
+        CookieValidation.validate_cookie 'https://localhost/', c
       end
     end
-    it "should lowercase addresses" do
-      Cookie.effective_host('FOO.COM').should == 'foo.com'
-    end
-  end
-  describe '.domains_match' do
-    it "should handle exact matches" do
-      Cookie.domains_match('foo', 'foo').should be_true
-      Cookie.domains_match('foo.com', 'foo.com').should be_true
-      Cookie.domains_match('127.0.0.1', '127.0.0.1').should be_true
-      Cookie.domains_match('::ffff:192.0.2.128', '::ffff:192.0.2.128').should be_true
-    end
-    it "should handle matching a superdomain" do
-      Cookie.domains_match('auth.foo.com', 'foo.com').should be_true
-      Cookie.domains_match('x.y.z.foo.com', 'y.z.foo.com').should be_true
-    end
-    it "should not match superdomains, or illegal domains" do
-      Cookie.domains_match('x.y.z.foo.com', 'z.foo.com').should be_false
-      Cookie.domains_match('foo.com', 'com').should be_false
-    end
-    it "should not match domains with and without a dot suffix together" do
-      Cookie.domains_match('foo.com.', 'foo.com').should be_false
-    end
-  end
-  describe '.hostname_reach' do
-    it "should find the next highest subdomain" do
-      {'www.google.com' => 'google.com', 'auth.corp.companyx.com' => 'corp.companyx.com'}.each do |entry|
-        Cookie.hostname_reach(entry[0]).should == entry[1]
-      end
-    end
-    it "should handle domains with suffixed dots" do
-      Cookie.hostname_reach('www.google.com.').should == 'google.com.'
-    end
-    it "should return nil for a root domain" do
-      Cookie.hostname_reach('github.com').should be_nil
-    end
-    it "should return 'local' for a local domain" do
-      ['foo.local', 'foo.local.'].each do |hostname|
-        Cookie.hostname_reach(hostname).should == 'local'
-      end
-    end
-    it "should handle mixed-case '.local'" do
-      Cookie.hostname_reach('foo.LOCAL').should == 'local'
-    end
-    it "should return nil for an IPv4 address" do
-      Cookie.hostname_reach('127.0.0.1').should be_nil
-    end
-    it "should return nil for IPv6 addresses" do
-      ['2001:db8:85a3::8a2e:370:7334', '::ffff:192.0.2.128'].each do |value|
-        Cookie.hostname_reach(value).should be_nil
-      end
+  rescue LoadError
+    it "does not appear the JSON library is installed" do
+      raise "please install the JSON library"
     end
   end
-end
+end