dwaite-cookiejar 0.1.1 → 0.1.2

data/lib/cookiejar/cookie.rb

@@ -1,5 +1,6 @@
 require 'time'
-require 'cookiejar/cookie_logic'
+require 'uri'
+require 'cookiejar/cookie_common'
 
 module CookieJar
   
@@ -9,9 +10,29 @@ module CookieJar
   # Specifically, the 'domain' and 'path' values may be set to defaults 
   # based on the requested resource that resulted in the cookie being set.
   class Cookie
-    include CookieLogic
-    extend CookieLogic
-    
+    module PATTERN
+      include URI::REGEXP::PATTERN
+
+      TOKEN = '[^(),\/<>@;:\\\"\[\]?={}\s]*'
+      VALUE1 = "([^;]*)"
+      IPADDR = "#{IPV4ADDR}|#{IPV6ADDR}"
+      BASE_HOSTNAME = "(?:#{DOMLABEL}\\.)(?:((?:(?:#{DOMLABEL}\\.)+(?:#{TOPLABEL}\\.?))|local))"
+
+      # QUOTED_PAIR = "\\\\[\\x00-\\x7F]"
+      # LWS = "\\r\\n(?:[ \\t]+)"
+      # TEXT="[\\t\\x20-\\x7E\\x80-\\xFF]|(?:#{LWS})"
+      # QDTEXT="[\\t\\x20-\\x21\\x23-\\x7E\\x80-\\xFF]|(?:#{LWS})"
+      # QUOTED_TEXT = "\\\"((?:#{QDTEXT}|#{QUOTED_PAIR})*)\\\""
+      # VALUE2 = "(#{TOKEN})|#{QUOTED_TEXT}"
+
+    end
+    BASE_HOSTNAME = /#{PATTERN::BASE_HOSTNAME}/
+    BASE_PATH = /\A((?:[^\/?#]*\/)*)/
+    IPADDR = /\A#{PATTERN::IPADDR}\Z/
+    # HDN = /\A#{PATTERN::HOSTNAME}\Z/
+    # TOKEN = /\A#{PATTERN::TOKEN}\Z/
+    # TWO_DOT_DOMAINS = /\A\.(com|edu|net|mil|gov|int|org)\Z/
+  
     # The mandatory name and value of the cookie
     attr_reader :name, :value
     # The domain and path of the cookie. These values will be set on all
@@ -54,25 +75,24 @@ module CookieJar
     end
     
     def expired?
-      expires_at != nil && (Time.now > expires_at)
+      expires_at != nil && Time.now > expires_at
     end
 
     # Create a cookie based on an absolute URI and the string value of a
     # 'Set-Cookie' header.
-    def self.from_set_cookie(request_uri, set_cookie_value)
-      include CookieLogic
-      args = {}
-      params=set_cookie_value.split(/;\s*/)
+    def self.from_set_cookie request_uri, set_cookie_value 
+      args = { }
+      params=set_cookie_value.split /;\s*/
       params.each do |param|
         result = PARAM1.match param
-        if (!result) 
-          raise InvalidCookieError.new("Invalid cookie parameter in cookie '#{set_cookie_value}'")
+        if !result
+          raise InvalidCookieError.new "Invalid cookie parameter in cookie '#{set_cookie_value}'"
         end
         key = result[1].downcase.to_sym
         keyvalue = result[2]
         case key
         when :expires
-          args[:expires_at] = Time.parse(keyvalue)
+          args[:expires_at] = Time.parse keyvalue
         when :domain
           args[:domain] = keyvalue
         when :path
@@ -95,7 +115,7 @@ module CookieJar
     end
 
     def to_s
-      %^"#{name}=#{value}#{if(domain) then "; domain=#{domain}" end}#{if (expiry) then "; expiry=#{expiry}" end}#{if (path) then "; path=#{path}" end}#{if (secure) then "; secure" end }#{if (http_only) then "; HTTPOnly" end}^
+      %^"#{name}=#{value}#{if domain then "; domain=#{domain}" end}#{if expiry then "; expiry=#{expiry}" end}#{if path then "; path=#{path}" end}#{if secure then "; secure" end }#{if http_only then "; HTTPOnly" end}^
     end
 
     # Check whether a cookie meets all of the rules to be created, based on 
@@ -153,7 +173,7 @@ module CookieJar
         end
       end
 
-      raise InvalidCookieError.new(errors) unless errors.empty?
+      raise InvalidCookieError.new errors unless errors.empty?
 
       # Note: 'secure' is not explicitly defined as an SSL channel, and no
       # test is defined around validity and the 'secure' attribute
@@ -173,11 +193,112 @@ module CookieJar
       expiry_match = !expired?
       path_match && secure_match && script_match && expiry_match
     end
+    
+    # Compute the base of a path.   
+    def self.cookie_base_path path
+      path = path.is_a?(URI) ? path.path : path
+      BASE_PATH.match(path)[1]
+    end
+    
+    # Processes cookie path data using the following rules:
+    # Paths are separated by '/' characters, and accepted values are truncated
+    # to the last '/' character. If no path is specified in the cookie, a path
+    # value will be taken from the request URI which was used for the site.
+    #
+    # Note that this will not attempt to detect a mismatch of the request uri domain
+    # and explicitly specified cookie path
+    def self.determine_cookie_path request_uri, cookie_path
+      uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
+      cookie_path = cookie_path.is_a?(Cookie) ? cookie_path.path : cookie_path
+    
+      if cookie_path == nil || cookie_path.empty?
+        cookie_path = cookie_base_path uri.path
+      end
+      cookie_path
+    end
+    
+    # Given a URI, compute the relevant search domains for pre-existing
+    # cookies. This includes all the valid dotted forms for a named or IP
+    # domains.
+    def self.compute_search_domains request_uri
+      uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
+      host = effective_host uri
+      result = [host]
+      if host !~ IPADDR
+        result << ".#{host}"
+      end
+      base = hostname_reach host
+      if base
+        result << ".#{base}"
+      end
+      result
+    end
+    
+    # Processes cookie domain data using the following rules:
+    # Domains strings of the form .foo.com match 'foo.com' and all immediate
+    # subdomains of 'foo.com'. Domain strings specified of the form 'foo.com' are
+    # modified to '.foo.com', and as such will still apply to subdomains.
+    #
+    # Cookies without an explicit domain will have their domain value taken directly
+    # from the URL, and will _NOT_ have any leading dot applied. For example, a request
+    # to http://foo.com/ will cause an entry for 'foo.com' to be created - which applies
+    # to foo.com but no subdomain.
+    #
+    # Note that this will not attempt to detect a mismatch of the request uri domain
+    # and explicitly specified cookie domain
+    def self.determine_cookie_domain request_uri, cookie_domain
+      uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
+      domain = cookie_domain.is_a?(Cookie) ? cookie_domain.domain : cookie_domain
+    
+      if domain == nil || domain.empty?
+        domain = effective_host uri.host
+      else
+        domain = domain.downcase
+        if domain =~ IPADDR || domain.start_with?('.')
+          domain
+        else
+          ".#{domain}" 
+        end
+      end
+    end
+    # Compute the effective host (RFC 2965, section 1)
+    # [host] a string or URI.
+    #
+    # Has the added additional logic of searching for interior dots specifically, and
+    # matches colons to prevent .local being suffixed on IPv6 addresses
+    def self.effective_host host
+      hostname = host.is_a?(URI) ? host.host : host
+      hostname = hostname.downcase
+    
+      if /.[\.:]./.match(hostname) || hostname == '.local'
+        hostname
+      else
+        hostname + '.local'
+      end
+    end  
+    # Compare a base domain against the base domain to see if they match, or
+    # if the base domain is reachable
+    def self.domains_match tested_domain,base_domain
+      return true if (tested_domain == base_domain || ".#{tested_domain}" == base_domain)
+      lhs = effective_host tested_domain
+      rhs = effective_host base_domain
+      lhs == rhs || ".#{lhs}" == rhs || hostname_reach(lhs) == rhs || ".#{hostname_reach lhs}" == rhs
+    end
+    # Compute the reach of a hostname (RFC 2965, section 1)
+    # Determines the next highest superdomain, or nil if none valid
+    def self.hostname_reach hostname
+      host = hostname.is_a?(URI) ? hostname.host : hostname
+      host = host.downcase
+      match = BASE_HOSTNAME.match host
+      if match
+        match[1]
+      end
+    end
   protected
     PARAM1 = /\A(#{PATTERN::TOKEN})(?:=#{PATTERN::VALUE1})?\Z/
     # PARAM2 = /\A(#{PATTERN::TOKEN})(?:=#{PATTERN::VALUE2})?\Z/
 
-    def initialize(*params)
+    def initialize *params
       case params.length
       when 1
         args = params[0]

data/lib/cookiejar/jar.rb

@@ -1,4 +1,4 @@
-require 'cookiejar/cookie_logic'
+require 'cookiejar/cookie'
 
 # A cookie store for client side usage. 
 # - Enforces cookie validity rules
@@ -42,7 +42,6 @@ require 'cookiejar/cookie_logic'
 # path. 
 module CookieJar
   class Jar
-    include CookieLogic
     def initialize
   	  @domains = {}
     end
@@ -53,10 +52,8 @@ module CookieJar
     # returns the Cookie object on success, otherwise raises an 
     # InvalidCookieError
     def set_cookie request_uri, cookie_header_value
-    	uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
-    	host = effective_host uri
-    	cookie = Cookie.from_set_cookie(uri, cookie_header_value)
-  	  domain_paths = find_or_add_domain_for_cookie(cookie.domain)
+    	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)
   	  cookie
     end
@@ -69,11 +66,11 @@ module CookieJar
     # - :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)
-    	hosts = compute_search_domains uri
+    	hosts = Cookie.compute_search_domains uri
 	
     	results = []
     	hosts.each do |host|
-    	  domain = find_domain_for_cookie host
+    	  domain = find_domain host
     	  domain.each do |path, cookies|
     		  if uri.path.start_with? path
       		  results += cookies.select do |name, cookie|
@@ -105,14 +102,12 @@ module CookieJar
 
   protected  
 
-    def find_domain_for_cookie domain
-    	domain = effective_host domain
-    	@domains[domain] || {}
+    def find_domain host
+    	@domains[host] || {}
     end
 
-    def find_or_add_domain_for_cookie(domain)
-    	domain = effective_host domain
-    	@domains[domain] ||= {}
+    def find_or_add_domain_for_cookie cookie
+    	@domains[cookie.domain] ||= {}
     end
 	
     def add_cookie_to_path (paths, cookie)

data/lib/cookiejar.rb

@@ -1,2 +1,3 @@
+require 'cookiejar/cookie_common'
 require 'cookiejar/cookie'
 require 'cookiejar/jar'

data/test/cookie_test.rb

@@ -1,8 +1,6 @@
 require 'cookiejar'
-require 'cookiejar/cookie_logic'
 
 include CookieJar
-include CookieLogic
 
 FOO_URL = 'http://localhost/foo'
 AMMO_URL = 'http://localhost/ammo'
@@ -31,6 +29,14 @@ describe Cookie do
       cookie.name.should == 'foo'
       cookie.value.should == 'bar'
     end
+    it "should normalize domain names" do
+      cookie = Cookie.from_set_cookie 'http://localhost/', 'foo=Bar;domain=LoCaLHoSt.local'
+      cookie.domain.should == '.localhost.local'
+    end
+    it "should accept non-normalized .local" do
+      cookie = Cookie.from_set_cookie 'http://localhost/', 'foo=bar;domain=.local'
+      cookie.domain.should == '.local'
+    end
   end
   describe '.validate_cookie' do
     localaddr = 'http://localhost/foo/bar/'
@@ -112,4 +118,153 @@ describe Cookie do
       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
+      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
+      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
+      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
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dwaite-cookiejar
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - David Waite
@@ -24,14 +24,13 @@ extra_rdoc_files: []
 files: 
 - lib/cookiejar/cookie.rb
 - lib/cookiejar/cookie_common.rb
-- lib/cookiejar/cookie_logic.rb
 - lib/cookiejar/jar.rb
 - lib/cookiejar.rb
-- test/cookie_logic_test.rb
 - test/cookie_test.rb
 - test/jar_test.rb
 has_rdoc: false
 homepage: http://alkaline-solutions.com
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --title
@@ -53,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Client-side HTTP Cookie library

data/lib/cookiejar/cookie_logic.rb

@@ -1,129 +0,0 @@
-require 'uri'
-require 'cookiejar/cookie_common'
-
-module CookieJar
-  module CookieLogic
-    module PATTERN
-      include URI::REGEXP::PATTERN
-
-      TOKEN = '[^(),\/<>@;:\\\"\[\]?={}\s]*'
-      VALUE1 = "([^;]*)"
-      IPADDR = "#{IPV4ADDR}|#{IPV6ADDR}"
-      BASE_HOSTNAME = "(?:#{DOMLABEL}\\.)((?:(?:#{DOMLABEL}\\.)+(?:#{TOPLABEL}\\.?)|local))"
-
-      # QUOTED_PAIR = "\\\\[\\x00-\\x7F]"
-      # LWS = "\\r\\n(?:[ \\t]+)"
-      # TEXT="[\\t\\x20-\\x7E\\x80-\\xFF]|(?:#{LWS})"
-      # QDTEXT="[\\t\\x20-\\x21\\x23-\\x7E\\x80-\\xFF]|(?:#{LWS})"
-      # QUOTED_TEXT = "\\\"((?:#{QDTEXT}|#{QUOTED_PAIR})*)\\\""
-      # VALUE2 = "(#{TOKEN})|#{QUOTED_TEXT}"
-
-    end
-    BASE_HOSTNAME = /#{PATTERN::BASE_HOSTNAME}/
-    BASE_PATH = /\A((?:[^\/?#]*\/)*)/
-    IPADDR = /\A#{PATTERN::IPADDR}\Z/
-    # HDN = /\A#{PATTERN::HOSTNAME}\Z/
-    # TOKEN = /\A#{PATTERN::TOKEN}\Z/
-    # TWO_DOT_DOMAINS = /\A\.(com|edu|net|mil|gov|int|org)\Z/
-  
-    # Compute the effective host (RFC 2965, section 1)
-    # [host] a string or URI.
-    #
-    # Has the added additional logic of searching for interior dots specifically, and
-    # matches colons to prevent .local being suffixed on IPv6 addresses
-    def effective_host(host)
-      hostname = host.is_a?(URI) ? host.host : host
-      hostname = hostname.downcase
-    
-      if /.(?:[\.:])./.match(hostname)
-        hostname
-      else
-        hostname + '.local'
-      end
-    end
-  
-    # Processes cookie domain data using the following rules:
-    # Domains strings of the form .foo.com match 'foo.com' and all immediate
-    # subdomains of 'foo.com'. Domain strings specified of the form 'foo.com' are
-    # modified to '.foo.com', and as such will still apply to subdomains.
-    #
-    # Cookies without an explicit domain will have their domain value taken directly
-    # from the URL, and will _NOT_ have any leading dot applied. For example, a request
-    # to http://foo.com/ will cause an entry for 'foo.com' to be created - which applies
-    # to foo.com but no subdomain.
-    #
-    # Note that this will not attempt to detect a mismatch of the request uri domain
-    # and explicitly specified cookie domain
-    def determine_cookie_domain (request_uri, cookie_domain)
-      uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
-      domain = cookie_domain.is_a?(Cookie) ? cookie_domain.domain : cookie_domain
-    
-      if domain == nil || domain.empty?
-        domain = effective_host(uri.host)
-      else
-        domain = domain.downcase
-        if (domain =~ IPADDR || domain.start_with?('.'))
-          domain
-        else
-          ".#{domain}" 
-        end
-      end
-    end
-
-    # Processes cookie path data using the following rules:
-    # Paths are separated by '/' characters, and accepted values are truncated
-    # to the last '/' character. If no path is specified in the cookie, a path
-    # value will be taken from the request URI which was used for the site.
-    #
-    # Note that this will not attempt to detect a mismatch of the request uri domain
-    # and explicitly specified cookie path
-    def determine_cookie_path(request_uri, cookie_path)
-      uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
-      cookie_path = cookie_path.is_a?(Cookie) ? cookie_path.path : cookie_path
-    
-      if (cookie_path == nil || cookie_path.empty?)
-        cookie_path = cookie_base_path uri.path
-      end
-      cookie_path
-    end
-
-    # Compute the reach of a hostname (RFC 2965, section 1)
-    # Determines the next highest superdomain, or nil if none valid
-    def hostname_reach hostname
-      host = hostname.is_a?(URI) ? hostname.host : hostname
-      BASE_HOSTNAME.match(host) && $~[1] || nil
-    end
-
-    # Compute the base of a path.   
-    def cookie_base_path(path)
-      path = path.is_a?(URI) ? path.path : path
-      BASE_PATH.match(path)[1]
-    end
-  
-    # Compare a base domain against the base domain to see if they match, or
-    # if the base domain is reachable
-    def domains_match tested_domain,base_domain
-      return true if (tested_domain == base_domain || ".#{tested_domain}" == base_domain)
-      lhs = effective_host tested_domain
-      rhs = effective_host base_domain
-      lhs == rhs || ".#{lhs}" == rhs || hostname_reach(lhs) == rhs || ".#{hostname_reach lhs}" == rhs
-    end
-  
-    # Given a URI, compute the relevant search domains for pre-existing
-    # cookies. This includes all the valid dotted forms for a named or IP
-    # domains.
-    def compute_search_domains request_uri
-      uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
-      host = effective_host uri
-      result = [host]
-      if (host !~ IPADDR)
-        result << ".#{host}"
-      end
-      base = hostname_reach host
-      if (base)
-        result << ".#{base}"
-      end
-      result
-    end
-  end
-end

data/test/cookie_logic_test.rb

@@ -1,157 +0,0 @@
-require 'cookiejar'
-require 'cookiejar/cookie_logic'
-include CookieJar
-
-describe CookieLogic do
-  include CookieLogic
-  
-  describe ".effective_host" do
-    it "should leave proper domains the same" do
-      ['google.com', 'www.google.com', 'google.com.'].each do |value|
-        effective_host(value).should == value
-      end
-    end
-    it "should handle a URI object" do
-      effective_host(URI.parse('http://example.com/')).should == 'example.com'
-    end	
-    it "should add a local suffix on unqualified hosts" do
-      effective_host('localhost').should == 'localhost.local'
-    end
-    it "should leave IPv4 addresses alone" do
-      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|
-        effective_host(value).should == value
-      end
-    end
-    it "should lowercase addresses" do
-      effective_host('FOO.COM').should == 'foo.com'
-    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|
-        hostname_reach(entry[0]).should == entry[1]
-      end
-    end
-    it "should handle domains with suffixed dots" do
-      hostname_reach('www.google.com.').should == 'google.com.'
-    end
-    it "should return nil for a root domain" do
-      hostname_reach('github.com').should be_nil
-    end
-    it "should return 'local' for a local domain" do
-      ['foo.local', 'foo.local.'].each do |hostname|
-        hostname_reach(hostname).should == 'local'
-      end
-    end
-    it "should return nil for an IPv4 address" do
-      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|
-        hostname_reach(value).should be_nil
-      end
-    end
-  end
-
-  describe '.cookie_base_path' do
-    it "should leave '/' alone" do
-      cookie_base_path('/').should == '/'
-    end
-    it "should strip off everything after the last '/'" do
-      cookie_base_path('/foo/bar/baz').should == '/foo/bar/'
-    end
-    it "should handle query parameters and fragments with slashes" do
-      cookie_base_path('/foo/bar?query=a/b/c#fragment/b/c').should == '/foo/'
-    end
-    it "should handle URI objects" do
-      cookie_base_path(URI.parse('http://www.foo.com/bar/')).should == '/bar/'
-    end
-    it "should preserve case" do
-      cookie_base_path("/BaR/").should == '/BaR/'
-    end
-  end
-  
-  describe '.determine_cookie_domain' do
-    it "should add a dot to the front of domains" do
-      determine_cookie_domain('http://foo.com/', 'foo.com').should == '.foo.com'
-    end
-    it "should not add a second dot if one present" do
-      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")
-      determine_cookie_domain('http://foo.com/', c).should == '.foo.com'
-    end
-    it "should handle URI objects" do
-      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
-      determine_cookie_domain('http://foo.com/', '').should == 'foo.com'
-    end
-    it "should leave IPv4 addresses alone" do
-      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|
-        determine_cookie_domain("http://[#{value}]/", value).should == value
-      end
-    end
-  end
-  describe '.determine_cookie_path' do
-    it "should use the requested path when none is specified for the cookie" do
-      determine_cookie_path('http://foo.com/', nil).should == '/'
-      determine_cookie_path('http://foo.com/bar/baz', '').should == '/bar/'
-    end
-    it "should handle URI objects" do
-      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=/")
-      determine_cookie_path('http://foo.com/', cookie).should == '/'
-    end
-    it "should ignore the request when a path is specified" do
-      determine_cookie_path('http://foo.com/ignorable/path', '/path/').should == '/path/'
-    end
-  end
-  describe '.domains_match' do
-    it "should handle exact matches" do
-      domains_match('foo', 'foo').should be_true
-      domains_match('foo.com', 'foo.com').should be_true
-      domains_match('127.0.0.1', '127.0.0.1').should be_true
-      domains_match('::ffff:192.0.2.128', '::ffff:192.0.2.128').should be_true
-    end
-    it "should handle matching a superdomain" do
-      domains_match('auth.foo.com', 'foo.com').should be_true
-      domains_match('x.y.z.foo.com', 'y.z.foo.com').should be_true
-    end
-    it "should not match superdomains, or illegal domains" do
-      domains_match('x.y.z.foo.com', 'z.foo.com').should be_false
-      domains_match('foo.com', 'com').should be_false
-    end
-    it "should not match domains with and without a dot suffix together" do
-      domains_match('foo.com.', 'foo.com').should be_false
-    end
-  end
-  describe '.compute_search_domains' do
-    it "should handle subdomains" do
-      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
-      compute_search_domains('http://foo.com/').should ==
-      ['foo.com', '.foo.com']
-    end
-    it "should handle IP addresses" do
-      compute_search_domains('http://127.0.0.1/').should ==
-      ['127.0.0.1']
-    end
-    it "should handle local addresses" do
-      compute_search_domains('http://zero/').should == 
-      ['zero.local', '.zero.local', '.local']
-    end
-  end
-end