http-cookie 1.0.0.pre10 → 1.0.0.pre11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f409469763d06151a3094c2246c64c71f8f0016a
-  data.tar.gz: 4c6433fa901c541aa2bf16461fbbe817fca00f4e
+  metadata.gz: 74a442b5c8222376568f11b2ed2f3ff948cb297a
+  data.tar.gz: 27b3d634fdd2e75bff0302f89463b5ed777e936f
 SHA512:
-  metadata.gz: ec86eccfc64ce5e1672b0ed786722deda4c0386deb564c7eec89ba965199717b603e517a8acdd0cbd560380585e8ed96e66ff9d8cf227ca716ab9c9b4dfabec1
-  data.tar.gz: ad8af975e1ec653bd2e978f21a1c8199160598c16a8bad6851a9d6b6a2ee3e069409858b31a7f076e37c59f697eeeec6f43b9309b6eff51f5acbc0767d9ac4e4
+  metadata.gz: 48ee26913f44add403e4d620e75b6f64156efaf23b37ab30e7c10543bd765a12adaeb25ff7f6c666410b82d291457f049d718ae4d802906be53db5a28638b89c
+  data.tar.gz: 7703dd086e0802411ab9e7ee9c12278a3321a41a0fcecdb203a6de3e2848c5c73e6e5a4141ccb01f65e165e1f80a3c8b3ea1a60be3505bb5ea1bcfa2bf55fc59

data/README.md

@@ -25,7 +25,7 @@ Or install it yourself as:
 ## Usage
 
     ########################
-    # Client side example
+    # Client side example 1
     ########################
 
     # Initialize a cookie jar
@@ -34,30 +34,60 @@ Or install it yourself as:
     # Load from a file
     jar.load(filename) if File.exist?(filename)
 
-    # Store received cookies
-    HTTP::Cookie.parse(set_cookie_header_value, origin: uri) { |cookie|
-      jar << cookie
+    # Store received cookies, where uri is the origin of this header
+    header["Set-Cookie"].each { |value|
+      jar.parse(value, uri)
     }
 
-    # Get the value for the Cookie field of a request header
-    cookie_header_value = jar.cookies(uri).join(', ')
+    # ...
+
+    # Set the Cookie header value, where uri is the destination URI
+    header["Cookie"] = HTTP::Cookie.cookie_value(jar.cookies(uri))
 
     # Save to a file
     jar.save(filename)
 
 
+    ########################
+    # Client side example 2
+    ########################
+
+    # Initialize a cookie jar using a Mozilla compatible SQLite3 backend
+    jar = HTTP::CookieJar.new(store: :mozilla, filename: 'cookies.sqlite')
+
+    # There is no need for load & save in this backend.
+
+    # Store received cookies, where uri is the origin of this header
+    header["Set-Cookie"].each { |value|
+      jar.parse(value, uri)
+    }
+
+    # ...
+
+    # Set the Cookie header value, where uri is the destination URI
+    header["Cookie"] = HTTP::Cookie.cookie_value(jar.cookies(uri))
+
+
     ########################
     # Server side example
     ########################
 
-    # Generate a cookie
-    cookies = HTTP::Cookie.new("uid", "a12345", domain: 'example.org',
+    # Generate a domain cookie
+    cookie1 = HTTP::Cookie.new("uid", "u12345", domain: 'example.org',
                                                 for_domain: true,
                                                 path: '/',
                                                 max_age: 7*86400)
 
-    # Get the value for the Set-Cookie field of a response header
-    set_cookie_header_value = cookies.set_cookie_value(my_url)
+    # Add it to the Set-Cookie response header
+    header['Set-Cookie'] = cookie1.set_cookie_value
+
+    # Generate a host-only cookie
+    cookie2 = HTTP::Cookie.new("aid", "a12345", origin: my_url,
+                                                path: '/',
+                                                max_age: 7*86400)
+
+    # Add it to the Set-Cookie response header
+    header['Set-Cookie'] = cookie2.set_cookie_value
 
 
 ## Incompatibilities with Mechanize::Cookie/CookieJar
@@ -77,14 +107,17 @@ equivalent using HTTP::Cookie:
 
         # after
         cookies1 = HTTP::Cookie.parse(set_cookie1, uri_or_url)
-        cookies2 = HTTP::Cookie.parse(set_cookie2, uri_or_url, :logger => log)
+        cookies2 = HTTP::Cookie.parse(set_cookie2, uri_or_url, logger: log)
+        # or you can directly store parsed cookies in your jar
+        jar.parse(set_cookie1, uri_or_url)
+        jar.parse(set_cookie1, uri_or_url, logger: log)
 
 - Mechanize::Cookie#version, #version=
 
-    There is no longer a sense of version in HTTP cookie.  The only
-    version number that has ever been defined was zero, and there will
-    be no other version since the version attribute has been removed
-    in RFC 6265.
+    There is no longer a sense of version in the HTTP cookie
+    specification.  The only version number ever defined was zero, and
+    there will be no other version defined since the version attribute
+    has been removed in RFC 6265.
 
 - Mechanize::Cookie#comment, #comment=
 

data/lib/http/cookie.rb

@@ -3,29 +3,12 @@ require 'http/cookie/version'
 require 'time'
 require 'uri'
 require 'domain_name'
+require 'http/cookie/ruby_compat'
 
 module HTTP
   autoload :CookieJar, 'http/cookie_jar'
 end
 
-# In Ruby < 1.9.3 URI() does not accept a URI object.
-if RUBY_VERSION < "1.9.3"
-  begin
-    URI(URI(''))
-  rescue
-    def URI(url) # :nodoc:
-      case url
-      when URI
-        url
-      when String
-        URI.parse(url)
-      else
-        raise ArgumentError, 'bad argument (expected URI object or URI string)'
-      end
-    end
-  end
-end
-
 # This class is used to represent an HTTP Cookie.
 class HTTP::Cookie
   # Maximum number of bytes per cookie (RFC 6265 6.1 requires 4096 at
@@ -48,31 +31,13 @@ class HTTP::Cookie
     expires     max_age
     created_at  accessed_at
   ]
-
-  if String.respond_to?(:try_convert)
-    def check_string_type(object)
-      String.try_convert(object)
-    end
-    private :check_string_type
-  else
-    def check_string_type(object)
-      if object.is_a?(String) ||
-          (object.respond_to?(:to_str) && (object = object.to_str).is_a?(String))
-        object
-      else
-        nil
-      end
-    end
-    private :check_string_type
-  end
   # :startdoc:
 
   # The cookie name.  It may not be nil or empty.
   #
-  # Trying to set a value with the normal setter method will raise
-  # ArgumentError only when it contains any of these characters:
-  # control characters (\x00-\x1F and \x7F), space and separators
-  # `,;\"=`.
+  # Assign a string containing any of the following characters will
+  # raise ArgumentError: control characters (`\x00-\x1F` and `\x7F`),
+  # space and separators `,;\"=`.
   #
   # Note that RFC 6265 4.1.1 lists more characters disallowed for use
   # in a cookie name, which are these: `<>@:/[]?{}`.  Using these
@@ -82,9 +47,12 @@ class HTTP::Cookie
 
   # The cookie value.
   #
-  # Trying to set a value with the normal setter method will raise an
-  # ArgumentError only when it contains any of these characters:
-  # control characters (\x00-\x1F and \x7F).
+  # Assign a string containing a control character (`\x00-\x1F` and
+  # `\x7F`) will raise ArgumentError.
+  #
+  # Assigning nil sets the value to an empty string and the expiration
+  # date to the Unix epoch.  This is a handy way to make a cookie for
+  # expiration.
   #
   # Note that RFC 6265 4.1.1 lists more characters disallowed for use
   # in a cookie value, which are these: ` ",;\`.  Using these
@@ -138,18 +106,21 @@ class HTTP::Cookie
   # :attr_accessor: max_age
 
   # :call-seq:
-  #     new(name, value)
-  #     new(name, value, attr_hash)
-  #     new(attr_hash)
+  #     new(name, value = nil)
+  #     new(name, value = nil, **attr_hash)
+  #     new(**attr_hash)
   #
   # Creates a cookie object.  For each key of `attr_hash`, the setter
   # is called if defined.  Each key can be either a symbol or a
-  # string, downcased or not.
+  # string of downcased attribute names.
   #
   # This methods accepts any attribute name for which a setter method
   # is defined.  Beware, however, any error (typically ArgumentError)
   # a setter method raises will be passed through.
   #
+  # If `value` is omitted or it is nil, an expiration cookie is
+  # created unless `max_age` or `expires` (`expires_at`) is given.
+  #
   # e.g.
   #
   #     new("uid", "a12345")
@@ -160,51 +131,82 @@ class HTTP::Cookie
   def initialize(*args)
     @origin = @domain = @path =
       @expires = @max_age = nil
-    @secure = @httponly = false
+    @for_domain = @secure = @httponly = false
     @session = true
     @created_at = @accessed_at = Time.now
-
-    case args.size
-    when 2
-      self.name, self.value = *args
-      @for_domain = false
-      return
-    when 3
-      self.name, self.value, attr_hash = *args
+    case argc = args.size
     when 1
-      attr_hash = args.first
+      if attr_hash = Hash.try_convert(args.last)
+        args.pop
+      else
+        self.name, self.value = args # value is set to nil
+        return
+      end
+    when 2..3
+      if attr_hash = Hash.try_convert(args.last)
+        args.pop
+        self.name, value = args
+      else
+        argc == 2 or
+          raise ArgumentError, "wrong number of arguments (#{argc} for 1-3)"
+        self.name, self.value = args
+        return
+      end
     else
-      raise ArgumentError, "wrong number of arguments (#{args.size} for 1-3)"
+      raise ArgumentError, "wrong number of arguments (#{argc} for 1-3)"
     end
     for_domain = false
     domain = max_age = origin = nil
     attr_hash.each_pair { |key, val|
-      skey = key.to_s.downcase
-      if skey.sub!(/\?\z/, '')
-        val = val ? true : false
-      end
-      case skey
-      when 'for_domain'
-        for_domain = !!val
-      when 'domain'
+      case key.to_sym
+      when :name
+        self.name = val
+      when :value
+        value = val
+      when :domain
         domain = val
-      when 'origin'
+      when :path
+        self.path = val
+      when :origin
         origin = val
-      when 'max_age'
+      when :for_domain, :for_domain?
+        for_domain = val
+      when :max_age
         # Let max_age take precedence over expires
         max_age = val
+      when :expires, :expires_at
+        self.expires = val
+      when :httponly, :httponly?
+        @httponly = val
+      when :secure, :secure?
+        @secure = val
+      when /[A-Z]/
+        warn "keyword should be downcased: #{key}" if $VERBOSE
+        key = key.downcase
+        redo
+      when Symbol
+        setter = :"#{key}="
+        if respond_to?(setter)
+          __send__(setter, val)
+        else
+          warn "unknown keyword: #{key}" if $VERBOSE
+        end
+      when String
+        key = key.to_sym
+        redo
       else
-        setter = :"#{skey}="
-        __send__(setter, val) if respond_to?(setter)
+        key = key.to_s
+        redo
       end
     }
-    if @name.nil? || @value.nil?
-      raise ArgumentError, "at least name and value must be specified"
+    if @name.nil?
+      raise ArgumentError, "name must be specified"
     end
     @for_domain = for_domain
     self.domain = domain if domain
     self.origin = origin if origin
     self.max_age = max_age if max_age
+    self.value = value.nil? && (@expires || @max_age) ? '' : value
   end
 
   autoload :Scanner, 'http/cookie/scanner'
@@ -238,11 +240,10 @@ class HTTP::Cookie
       target_path[bsize] == ?/
     end
 
-    # Parses a Set-Cookie header value `set_cookie` into an array of
-    # Cookie objects taking `origin` as the source URI/URL.  Parts
-    # (separated by commas) that are malformed or invalid are silently
-    # ignored.  For example, cookies that a given origin is not
-    # allowed to issue are excluded from the resulted array.
+    # Parses a Set-Cookie header value `set_cookie` assuming that it
+    # is sent from a source URI/URL `origin`, and returns an array of
+    # Cookie objects.  Parts (separated by commas) that are malformed
+    # or considered unacceptable are silently ignored.
     #
     # If a block is given, each cookie object is passed to the block.
     #
@@ -280,9 +281,7 @@ class HTTP::Cookie
       origin = URI(origin)
 
       [].tap { |cookies|
-        s = Scanner.new(set_cookie, logger)
-        until s.eos?
-          name, value, attrs = s.scan_cookie
+        Scanner.new(set_cookie, logger).scan_set_cookie { |name, value, attrs|
           break if name.nil? || name.empty?
 
           cookie = new(name, value)
@@ -319,7 +318,24 @@ class HTTP::Cookie
           yield cookie if block_given?
 
           cookies << cookie
-        end
+        }
+      }
+    end
+
+    # Takes an array of cookies and returns a string for use in the
+    # Cookie header, like "name1=value2; name2=value2".
+    def cookie_value(cookies)
+      cookies.join('; ')
+    end
+
+    # Parses a Cookie header value into a hash of name-value string
+    # pairs.  The first appearance takes precedence if multiple pairs
+    # with the same name occur.
+    def cookie_value_to_hash(cookie_value)
+      {}.tap { |hash|
+        Scanner.new(cookie_value).scan_cookie { |name, value|
+          hash[name] ||= value
+        }
       }
     end
   end
@@ -328,7 +344,7 @@ class HTTP::Cookie
 
   # See #name.
   def name=(name)
-    name = check_string_type(name) or
+    name = String.try_convert(name) or
       raise TypeError, "#{name.class} is not a String"
     if name.empty?
       raise ArgumentError, "cookie name cannot be empty"
@@ -345,7 +361,11 @@ class HTTP::Cookie
 
   # See #value.
   def value=(value)
-    value = check_string_type(value) or
+    if value.nil?
+      self.expires = UNIX_EPOCH
+      return @value = ''
+    end
+    value = String.try_convert(value) or
       raise TypeError, "#{value.class} is not a String"
     if value.match(/[\x00-\x1F\x7F]/)
       raise ArgumentError, "invalid cookie value"
@@ -373,7 +393,7 @@ class HTTP::Cookie
     when DomainName
       @domain_name = domain
     else
-      domain = check_string_type(domain) or
+      domain = String.try_convert(domain) or
         raise TypeError, "#{domain.class} is not a String"
       if domain.start_with?('.')
         for_domain = true
@@ -418,7 +438,7 @@ class HTTP::Cookie
 
   # See #path.
   def path=(path)
-    path = check_string_type(path) or
+    path = String.try_convert(path) or
       raise TypeError, "#{path.class} is not a String"
     @path = path.start_with?('/') ? path : '/'
   end
@@ -484,7 +504,7 @@ class HTTP::Cookie
     case sec
     when Integer, nil
     else
-      str = check_string_type(sec) or
+      str = String.try_convert(sec) or
         raise TypeError, "#{sec.class} is not an Integer or String"
       /\A-?\d+\z/.match(str) or
         raise ArgumentError, "invalid Max-Age: #{sec.inspect}"
@@ -566,29 +586,32 @@ class HTTP::Cookie
     acceptable_from_uri?(uri) && HTTP::Cookie.path_match?(@path, uri.path)
   end
 
-  # Returns a string for use in a Cookie header value,
-  # i.e. "name=value".
+  # Returns a string for use in the Cookie header, i.e. `name=value`
+  # or `name="value"`.
   def cookie_value
     "#{@name}=#{Scanner.quote(@value)}"
   end
   alias to_s cookie_value
 
-  # Returns a string for use in a Set-Cookie header value.  If the
-  # cookie does not have an origin set, one must be given from the
-  # argument.
-  #
-  # This method does not check if this cookie will be accepted from
-  # the origin.
-  def set_cookie_value(origin = nil)
-    origin = origin ? URI(origin) : @origin or
-      raise "origin must be specified to produce a value for Set-Cookie"
-
+  # Returns a string for use in the Set-Cookie header.  If necessary
+  # information like a path or domain (when `for_domain` is set) is
+  # missing, RuntimeError is raised.  It is always the best to set an
+  # origin before calling this method.
+  def set_cookie_value
     string = cookie_value
     if @for_domain
-      string << "; Domain=#{@domain}"
+      if @domain
+        string << "; Domain=#{@domain}"
+      else
+        raise "for_domain is specified but domain is known"
+      end
     end
-    if (origin + './').path != @path
-      string << "; Path=#{@path}"
+    if @path
+      if !@origin || (@origin + './').path != @path
+        string << "; Path=#{@path}"
+      end
+    else
+      raise "path is known"
     end
     if @max_age
       string << "; Max-Age=#{@max_age}"
@@ -608,7 +631,6 @@ class HTTP::Cookie
     '#<%s:' % self.class << PERSISTENT_PROPERTIES.map { |key|
       '%s=%s' % [key, instance_variable_get(:"@#{key}").inspect]
     }.join(', ') << ' origin=%s>' % [@origin ? @origin.to_s : 'nil']
-
   end
 
   # Compares the cookie with another.  When there are many cookies with
@@ -643,6 +665,7 @@ class HTTP::Cookie
   # YAML deserialization helper for Psych.
   def yaml_initialize(tag, map)
     expires = nil
+    @origin = nil
     map.each { |key, value|
       case key
       when 'expires'

data/lib/http/cookie/ruby_compat.rb

@@ -0,0 +1,59 @@
+class Array
+  def select!
+    i = 0
+    each_with_index { |x, j|
+      yield x or next
+      self[i] = x if i != j
+      i += 1
+    }
+    return nil if i == size
+    self[i..-1] = []
+    self
+  end unless method_defined?(:select!)
+end
+
+class Hash
+  class << self
+    def try_convert(object)
+      if object.is_a?(Hash) ||
+          (object.respond_to?(:to_hash) && (object = object.to_hash).is_a?(Hash))
+        object
+      else
+        nil
+      end
+    end unless method_defined?(:try_convert)
+  end
+end
+
+class String
+  class << self
+    def try_convert(object)
+      if object.is_a?(String) ||
+          (object.respond_to?(:to_str) && (object = object.to_str).is_a?(String))
+        object
+      else
+        nil
+      end
+    end unless method_defined?(:try_convert)
+  end
+end
+
+# In Ruby < 1.9.3 URI() does not accept a URI object.
+if RUBY_VERSION < "1.9.3"
+  require 'uri'
+
+  begin
+    URI(URI(''))
+  rescue
+    def URI(url) # :nodoc:
+      case url
+      when URI
+        url
+      when String
+        URI.parse(url)
+      else
+        raise ArgumentError, 'bad argument (expected URI object or URI string)'
+      end
+    end
+  end
+end

data/lib/http/cookie/scanner.rb

@@ -143,15 +143,23 @@ class HTTP::Cookie::Scanner < StringScanner
       year += 2000
     end
 
-    if (time <=> [23,59,59]) > 0
+    hh, mm, ss = time
+    if hh > 23 || mm > 59 || ss > 59
       return nil
     end
 
     tuple_to_time(day_of_month, month, year, time)
   end
 
-  def scan_cookie
-    # cf. RFC 6265 5.2
+  def scan_set_cookie
+    unless block_given?
+      scan_set_cookie { |*values|
+        return values
+      }
+      return
+    end
+
+    # RFC 6265 4.1.1 & 5.2
     until eos?
       start = pos
       len = nil
@@ -159,9 +167,7 @@ class HTTP::Cookie::Scanner < StringScanner
       skip_wsp
 
       name, value = scan_name_value
-      if name.nil?
-        break
-      elsif value.nil?
+      if value.nil?
         @logger.warn("Cookie definition lacks a name-value pair.") if @logger
       elsif name.empty?
         @logger.warn("Cookie definition has an empty name.") if @logger
@@ -171,12 +177,13 @@ class HTTP::Cookie::Scanner < StringScanner
 
       case
       when skip(/,/)
+        # The comma is used as separator for concatenating multiple
+        # values of a header.
         len = (pos - 1) - start
         break
       when skip(/;/)
         skip_wsp
         aname, avalue = scan_name_value
-        break if aname.nil?
         next if aname.empty? || value.nil?
         aname.downcase!
         case aname
@@ -209,7 +216,29 @@ class HTTP::Cookie::Scanner < StringScanner
         next
       end
 
-      return [name, value, attrs] if value
+      yield name, value, attrs if value
+    end
+  end
+
+  def scan_cookie
+    unless block_given?
+      scan_cookie { |*values|
+        return values
+      }
+      return
+    end
+
+    # RFC 6265 4.1.1 & 5.4
+    until eos?
+      skip_wsp
+
+      name, value = scan_name_value
+
+      yield name, value if value
+
+      # The comma is used as separator for concatenating multiple
+      # values of a header.
+      skip(/[;,]/)
     end
   end
 end

data/lib/http/cookie/version.rb

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

data/lib/http/cookie_jar.rb

@@ -49,6 +49,10 @@ class HTTP::CookieJar
   # any case.  A given cookie must have domain and path attributes
   # set, or ArgumentError is raised.
   #
+  # Whether a cookie with the `for_domain` flag on overwrites another
+  # with the flag off or vice versa depends on the store used.  See
+  # individual store classes for that matter.
+  #
   # ### Compatibility Note for Mechanize::Cookie users
   #
   # In HTTP::Cookie, each cookie object can store its origin URI
@@ -70,12 +74,22 @@ class HTTP::CookieJar
   end
   alias << add
 
-  # Gets an array of cookies that should be sent for the URL/URI.
-  def cookies(url)
-    now = Time.now
-    each(url).select { |cookie|
-      !cookie.expired? && (cookie.accessed_at = now)
-    }.sort
+  # Deletes a cookie that has the same name, domain and path as a
+  # given cookie from the jar and returns self.
+  #
+  # How the `for_domain` flag value affects the set of deleted cookies
+  # depends on the store used.  See individual store classes for that
+  # matter.
+  def delete(cookie)
+    @store.delete(cookie)
+    self
+  end
+
+  # Gets an array of cookies sorted by the path and creation time.  If
+  # `url` is given, only ones that should be sent to the URL/URI are
+  # selected, with the access time of each of them updated.
+  def cookies(url = nil)
+    each(url).sort
   end
 
   # Tests if the jar is empty.  If `url` is given, tests if there is
@@ -89,7 +103,8 @@ class HTTP::CookieJar
     end
   end
 
-  # Iterates over all cookies that are not expired.
+  # Iterates over all cookies that are not expired in no particular
+  # order.
   #
   # An optional argument `uri` specifies a URI/URL indicating the
   # destination of the cookies being selected.  Every cookie yielded
@@ -111,10 +126,13 @@ class HTTP::CookieJar
   end
   include Enumerable
 
-  # Parses a Set-Cookie field value `set_cookie` sent from a URI
-  # `origin` and adds the cookies parsed as valid to the jar.  Returns
-  # an array of cookies that have been added.  If a block is given, it
-  # is called after each cookie is added.
+  # Parses a Set-Cookie field value `set_cookie` assuming that it is
+  # sent from a source URL/URI `origin`, and adds the cookies parsed
+  # as valid and considered acceptable to the jar.  Returns an array
+  # of cookies that have been added.
+  #
+  # If a block is given, it is called for each cookie and the cookie
+  # is added only if the block returns a true value.
   #
   # `jar.parse(set_cookie, origin)` is a shorthand for this:
   #
@@ -125,16 +143,15 @@ class HTTP::CookieJar
   # See HTTP::Cookie.parse for available options.
   def parse(set_cookie, origin, options = nil) # :yield: cookie
     if block_given?
-      HTTP::Cookie.parse(set_cookie, origin, options) { |cookie|
-        add(cookie)
-        yield cookie
+      HTTP::Cookie.parse(set_cookie, origin, options).tap { |cookies|
+        cookies.select! { |cookie|
+          yield(cookie) && add(cookie)
+        }
       }
     else
       HTTP::Cookie.parse(set_cookie, origin, options) { |cookie|
         add(cookie)
       }
-      # XXX: ruby 1.8 fails to call super from a proc'ized method
-      # HTTP::Cookie.parse(set_cookie, origin, options, &method(:add)
     end
   end
 
@@ -154,7 +171,7 @@ class HTTP::CookieJar
   #       <dt>:yaml</dt>
   #       <dd>YAML structure (default)</dd>
   #       <dt>:cookiestxt</dt>
-  #       <dd>: Mozilla's cookies.txt format</dd>
+  #       <dd>Mozilla's cookies.txt format</dd>
   #     </dl>
   #
   # * `:session`

data/lib/http/cookie_jar/abstract_saver.rb

@@ -37,7 +37,7 @@ class HTTP::CookieJar::AbstractSaver
     # Initializes each instance variable of the same name as option
     # keyword.
     default_options.each_pair { |key, default|
-      instance_variable_set("@#{key}", options.key?(key) ? options[key] : default)
+      instance_variable_set("@#{key}", options.fetch(key, default))
     }
   end
 

data/lib/http/cookie_jar/abstract_store.rb

@@ -41,7 +41,7 @@ class HTTP::CookieJar::AbstractStore
     # Initializes each instance variable of the same name as option
     # keyword.
     default_options.each_pair { |key, default|
-      instance_variable_set("@#{key}", options.key?(key) ? options[key] : default)
+      instance_variable_set("@#{key}", options.fetch(key, default))
     }
   end
 

data/lib/http/cookie_jar/hash_store.rb

@@ -55,14 +55,14 @@ class HTTP::CookieJar
     end
 
     def add(cookie)
-      path_cookies = ((@jar[cookie.domain_name.hostname] ||= {})[cookie.path] ||= {})
+      path_cookies = ((@jar[cookie.domain] ||= {})[cookie.path] ||= {})
       path_cookies[cookie.name] = cookie
       cleanup if (@gc_index += 1) >= @gc_threshold
       self
     end
 
     def delete(cookie)
-      path_cookies = ((@jar[cookie.domain_name.hostname] ||= {})[cookie.path] ||= {})
+      path_cookies = ((@jar[cookie.domain] ||= {})[cookie.path] ||= {})
       path_cookies.delete(cookie.name)
       self
     end

data/lib/http/cookie_jar/mozilla_store.rb

@@ -255,7 +255,7 @@ class HTTP::CookieJar
       db_delete(cookie)
     end
 
-    def each(uri = nil)
+    def each(uri = nil, &block)
       now = Time.now
       if uri
         @st_cookies_for_domain ||=
@@ -304,7 +304,7 @@ class HTTP::CookieJar
             yield cookie
           end
         }
-        @sjar.each(uri, &proc)
+        @sjar.each(uri, &block)
       else
         @st_all_cookies ||=
           @db.prepare(<<-'SQL')
@@ -333,7 +333,7 @@ class HTTP::CookieJar
 
           yield cookie
         }
-        @sjar.each(&proc)
+        @sjar.each(&block)
       end
       self
     end

data/test/test_http_cookie.rb

@@ -50,10 +50,29 @@ class TestHTTPCookie < Test::Unit::TestCase
       silently do
         assert_equal 1, HTTP::Cookie.parse(cookie, url) { |c|
           assert c.expires, "Tried parsing: #{date}"
-          assert_equal(true, c.expires < yesterday)
+          assert_send [c.expires, :<, yesterday]
         }.size
       end
     end
+
+    [
+      ["PREF=1; expires=Wed, 01 Jan 100 12:34:56 GMT", nil],
+      ["PREF=1; expires=Sat, 01 Jan 1600 12:34:56 GMT", nil],
+      ["PREF=1; expires=Tue, 01 Jan 69 12:34:56 GMT", 2069],
+      ["PREF=1; expires=Thu, 01 Jan 70 12:34:56 GMT", 1970],
+      ["PREF=1; expires=Wed, 01 Jan 20 12:34:56 GMT", 2020],
+      ["PREF=1; expires=Sat, 01 Jan 2020 12:34:60 GMT", nil],
+      ["PREF=1; expires=Sat, 01 Jan 2020 12:60:56 GMT", nil],
+      ["PREF=1; expires=Sat, 01 Jan 2020 24:00:00 GMT", nil],
+      ["PREF=1; expires=Sat, 32 Jan 2020 12:34:56 GMT", nil],
+    ].each { |set_cookie, year|
+      cookie, = HTTP::Cookie.parse(set_cookie, url)
+      if year
+        assert_equal year, cookie.expires.year, "#{set_cookie}: expires in #{year}"
+      else
+        assert_equal nil, cookie.expires, "#{set_cookie}: invalid expiry date"
+      end
+    }
   end
 
   def test_parse_empty
@@ -105,6 +124,18 @@ class TestHTTPCookie < Test::Unit::TestCase
     }.size
   end
 
+  def test_parse_no_nothing
+    cookie = '; "", ;'
+    url = URI.parse('http://www.example.com/')
+    assert_equal 0, HTTP::Cookie.parse(cookie, url).size
+  end
+
+  def test_parse_no_name
+    cookie = '=no-name; path=/'
+    url = URI.parse('http://www.example.com/')
+    assert_equal 0, HTTP::Cookie.parse(cookie, url).size
+  end
+
   def test_parse_weird_cookie
     cookie = 'n/a, ASPSESSIONIDCSRRQDQR=FBLDGHPBNDJCPCGNCPAENELB; path=/'
     url = URI.parse('http://www.searchinnovation.com/')
@@ -400,13 +431,51 @@ class TestHTTPCookie < Test::Unit::TestCase
       cookie = HTTP::Cookie.new('foo', value)
       assert_equal(cookie_value, cookie.cookie_value)
     }
+
+    pairs = [
+      ['Foo', 'value1'],
+      ['Bar', 'value 2'],
+      ['Baz', 'value3'],
+      ['Bar', 'value"4'],
+    ]
+
+    cookie_value = HTTP::Cookie.cookie_value(pairs.map { |name, value|
+        HTTP::Cookie.new(:name => name, :value => value)
+      })
+
+    assert_equal 'Foo=value1; Bar="value 2"; Baz=value3; Bar="value\\"4"', cookie_value
+
+    hash = HTTP::Cookie.cookie_value_to_hash(cookie_value)
+
+    assert_equal 3, hash.size
+
+    hash.each_pair { |name, value|
+      _, pvalue = pairs.assoc(name)
+      assert_equal pvalue, value
+    }
   end
 
   def test_set_cookie_value
-    url = URI.parse('http://rubyforge.org/')
+    url = URI.parse('http://rubyforge.org/path/')
+
+    [
+      HTTP::Cookie.new('a', 'b', :domain => 'rubyforge.org', :path => '/path/'),
+      HTTP::Cookie.new('a', 'b', :origin => url),
+    ].each { |cookie|
+      cookie.set_cookie_value
+    }
+
+    [
+      HTTP::Cookie.new('a', 'b', :domain => 'rubyforge.org'),
+      HTTP::Cookie.new('a', 'b', :for_domain => true, :path => '/path/'),
+    ].each { |cookie|
+      assert_raises(RuntimeError) {
+        cookie.set_cookie_value
+      }
+    }
 
     ['foo=bar', 'foo="bar"', 'foo="ba\"r baz"'].each { |cookie_value|
-      cookie_params = @cookie_params.merge('secure' => 'secure', 'max-age' => 'Max-Age=1000')
+      cookie_params = @cookie_params.merge('path' => '/path/', 'secure' => 'secure', 'max-age' => 'Max-Age=1000')
       date = Time.at(Time.now.to_i)
       cookie_params.keys.combine.each do |keys|
         cookie_text = [cookie_value, *keys.map { |key| cookie_params[key] }].join('; ')
@@ -510,11 +579,34 @@ class TestHTTPCookie < Test::Unit::TestCase
       cookie.acceptable?
     }
 
-    assert_raises(ArgumentError) { HTTP::Cookie.new(:name => 'name') }
+    assert_raises(ArgumentError) { HTTP::Cookie.new() }
     assert_raises(ArgumentError) { HTTP::Cookie.new(:value => 'value') }
     assert_raises(ArgumentError) { HTTP::Cookie.new('', 'value') }
     assert_raises(ArgumentError) { HTTP::Cookie.new('key=key', 'value') }
     assert_raises(ArgumentError) { HTTP::Cookie.new("key\tkey", 'value') }
+    assert_raises(ArgumentError) { HTTP::Cookie.new('key', 'value', 'something') }
+    assert_raises(ArgumentError) { HTTP::Cookie.new('key', 'value', {}, 'something') }
+
+    [
+      HTTP::Cookie.new(:name => 'name'),
+      HTTP::Cookie.new("key", nil, :for_domain => true),
+      HTTP::Cookie.new("key", nil),
+      HTTP::Cookie.new("key", :secure => true),
+      HTTP::Cookie.new("key"),
+    ].each { |cookie|
+      assert_equal '', cookie.value
+      assert_equal true, cookie.expired?
+    }
+
+    [
+      HTTP::Cookie.new(:name => 'name', :max_age => 3600),
+      HTTP::Cookie.new("key", nil, :expires => Time.now + 3600),
+      HTTP::Cookie.new("key", :expires => Time.now + 3600),
+      HTTP::Cookie.new("key", :expires => Time.now + 3600, :value => nil),
+    ].each { |cookie|
+      assert_equal '', cookie.value
+      assert_equal false, cookie.expired?
+    }
   end
 
   def cookie_values(options = {})
@@ -681,6 +773,22 @@ class TestHTTPCookie < Test::Unit::TestCase
     assert_equal false, cookie.acceptable?
   end
 
+  def test_value
+    cookie = HTTP::Cookie.new('name', 'value')
+    assert_equal 'value', cookie.value
+
+    cookie.value = 'new value'
+    assert_equal 'new value', cookie.value
+
+    assert_raises(ArgumentError) { cookie.value = "a\tb" }
+    assert_raises(ArgumentError) { cookie.value = "a\nb" }
+
+    assert_equal false, cookie.expired?
+    cookie.value = nil
+    assert_equal '', cookie.value
+    assert_equal true, cookie.expired?
+  end
+
   def test_path
     uri = URI.parse('http://example.com/foo/bar')
 

data/test/test_http_cookie_jar.rb

@@ -2,6 +2,24 @@ require File.expand_path('helper', File.dirname(__FILE__))
 require 'tmpdir'
 
 module TestHTTPCookieJar
+  class TestBasic < Test::Unit::TestCase
+    def test_store
+      jar = HTTP::CookieJar.new(:store => :hash)
+      assert_instance_of HTTP::CookieJar::HashStore, jar.store
+
+      assert_raises(IndexError) {
+        jar = HTTP::CookieJar.new(:store => :nonexistent)
+      }
+
+      jar = HTTP::CookieJar.new(:store => HTTP::CookieJar::HashStore.new)
+      assert_instance_of HTTP::CookieJar::HashStore, jar.store
+
+      assert_raises(TypeError) {
+        jar = HTTP::CookieJar.new(:store => HTTP::CookieJar::HashStore)
+      }
+    end
+  end
+
   module Tests
     def setup(options = nil, options2 = nil)
       default_options = {
@@ -13,7 +31,7 @@ module TestHTTPCookieJar
       @store_type = new_options[:store]
       @gc_threshold = new_options[:gc_threshold]
       @jar  = HTTP::CookieJar.new(new_options)
-      @jar2 = HTTP::CookieJar.new(new_options)
+      @jar2 = HTTP::CookieJar.new(new_options2)
     end
 
     def hash_store?
@@ -303,6 +321,14 @@ module TestHTTPCookieJar
       assert_equal(0, @jar.cookies(url).length)
     end
 
+    def test_save_nonexistent_saver
+      Dir.mktmpdir { |dir|
+        assert_raises(ArgumentError) {
+          @jar.save(File.join(dir, "file"), :nonexistent)
+        }
+      }
+    end
+
     def test_save_cookies_yaml
       url = URI 'http://rubyforge.org/'
 
@@ -310,7 +336,6 @@ module TestHTTPCookieJar
       cookie = HTTP::Cookie.new(cookie_values(:origin => url))
       s_cookie = HTTP::Cookie.new(cookie_values(:name => 'Bar',
           :expires => nil,
-          :session => true,
           :origin => url))
 
       @jar.add(cookie)
@@ -335,14 +360,53 @@ module TestHTTPCookieJar
       assert_equal(3, @jar.cookies(url).length)
     end
 
+    def test_save_load_signature
+      Dir.mktmpdir { |dir|
+        filename = File.join(dir, "cookies.yml")
+
+        @jar.save(filename, :format => :cookiestxt, :session => true)
+        @jar.save(filename, :format => :cookiestxt, :session => true)
+        @jar.save(filename, :format => :cookiestxt)
+        @jar.save(filename, :cookiestxt, :session => true)
+        @jar.save(filename, :cookiestxt)
+        @jar.save(filename, :session => true)
+        @jar.save(filename)
+        assert_raises(ArgumentError) {
+          @jar.save()
+        }
+        assert_raises(ArgumentError) {
+          @jar.save(filename, { :format => :cookiestxt }, { :session => true })
+        }
+        assert_raises(ArgumentError) {
+          @jar.save(filename, :cookiestxt, { :session => true }, { :format => :cookiestxt })
+        }
+
+        @jar.load(filename, :format => :cookiestxt, :linefeed => "\n")
+        @jar.load(filename, :format => :cookiestxt, :linefeed => "\n")
+        @jar.load(filename, :format => :cookiestxt)
+        @jar.load(filename, :cookiestxt, :linefeed => "\n")
+        @jar.load(filename, :cookiestxt)
+        @jar.load(filename, :linefeed => "\n")
+        @jar.load(filename)
+        assert_raises(ArgumentError) {
+          @jar.load()
+        }
+        assert_raises(ArgumentError) {
+          @jar.load(filename, { :format => :cookiestxt }, { :linefeed => "\n" })
+        }
+        assert_raises(ArgumentError) {
+          @jar.load(filename, :cookiestxt, { :linefeed => "\n" }, { :format => :cookiestxt })
+        }
+      }
+    end
+
     def test_save_session_cookies_yaml
       url = URI 'http://rubyforge.org/'
 
       # Add one cookie with an expiration date in the future
       cookie = HTTP::Cookie.new(cookie_values)
       s_cookie = HTTP::Cookie.new(cookie_values(:name => 'Bar',
-          :expires => nil,
-          :session => true))
+          :expires => nil))
 
       @jar.add(cookie)
       @jar.add(s_cookie)
@@ -360,7 +424,6 @@ module TestHTTPCookieJar
       assert_equal(3, @jar.cookies(url).length)
     end
 
-
     def test_save_and_read_cookiestxt
       url = URI 'http://rubyforge.org/foo/'
 
@@ -368,8 +431,7 @@ module TestHTTPCookieJar
       cookie = HTTP::Cookie.new(cookie_values)
       expires = cookie.expires
       s_cookie = HTTP::Cookie.new(cookie_values(:name => 'Bar',
-          :expires => nil,
-          :session => true))
+          :expires => nil))
       cookie2 = HTTP::Cookie.new(cookie_values(:name => 'Baz',
           :value => 'Foo#Baz',
           :path => '/foo/',
@@ -394,6 +456,13 @@ module TestHTTPCookieJar
 
         content = File.read(filename)
 
+        filename2 = File.join(dir, "cookies2.txt")
+        open(filename2, 'w') { |w|
+          w.puts '# HTTP Cookie File'
+          @jar.save(w, :cookiestxt, :header => nil)
+        }
+        assert_equal content, File.read(filename2)
+
         assert_match(/^\.rubyforge\.org\t.*\tFoo\t/, content)
         assert_match(/^rubyforge\.org\t.*\tBaz\t/, content)
         assert_match(/^#HttpOnly_\.rubyforge\.org\t/, content)
@@ -554,17 +623,43 @@ module TestHTTPCookieJar
       assert_equal('Foo1 Foo2', @jar.cookies(surl).map { |c| c.name }.sort.join(' ') )
     end
 
-    def _test_delete
-      nurl = URI 'http://rubyforge.org/login'
-      surl = URI 'https://rubyforge.org/login'
+    def test_delete
+      cookie1 = HTTP::Cookie.new(cookie_values)
+      cookie2 = HTTP::Cookie.new(:name => 'Foo', :value => '',
+                                 :domain => 'rubyforge.org',
+                                 :for_domain => false,
+                                 :path => '/')
+      cookie3 = HTTP::Cookie.new(:name => 'Foo', :value => '',
+                                 :domain => 'rubyforge.org',
+                                 :for_domain => true,
+                                 :path => '/')
 
-      cookie1 = HTTP::Cookie.new(cookie_values(:name => 'Foo1', :origin => nurl))
-      cookie2 = HTTP::Cookie.new(cookie_values(:name => 'Foo1', :origin => surl))
+      @jar.add(cookie1)
+      @jar.delete(cookie2)
 
-      @jar.add(nncookie)
-      @jar.add(sncookie)
-      @jar.add(nscookie)
-      @jar.add(sscookie)
+      if mozilla_store?
+        assert_equal(1, @jar.to_a.length)
+        @jar.delete(cookie3)
+      end
+
+      assert_equal(0, @jar.to_a.length)
+    end
+
+    def test_accessed_at
+      orig = HTTP::Cookie.new(cookie_values(:expires => nil))
+      @jar.add(orig)
+
+      time = orig.accessed_at
+
+      assert_in_delta 1.0, time, Time.now, "accessed_at is initialized to the current time"
+
+      cookie, = @jar.to_a
+
+      assert_equal time, cookie.accessed_at, "accessed_at is not updated by each()"
+
+      cookie, = @jar.cookies("http://rubyforge.org/")
+
+      assert_send [cookie.accessed_at, :>, time], "accessed_at is not updated by each(url)"
     end
 
     def test_max_cookies
@@ -614,14 +709,38 @@ module TestHTTPCookieJar
         }
       }
 
-      assert_equal true, count > slimit
-      assert_equal true, @jar.to_a.size <= slimit
+      assert_send [count, :>, slimit]
+      assert_send [@jar.to_a.size, :<=, slimit]
       @jar.cleanup
       assert_equal hlimit, @jar.to_a.size
       assert_equal false, @jar.any? { |cookie|
         cookie.domain == cookie.value
       }
     end
+
+    def test_parse
+      set_cookie = [
+        "name=Akinori; Domain=rubyforge.org; Expires=Sun, 08 Aug 2076 19:00:00 GMT; Path=/",
+        "country=Japan; Domain=rubyforge.org; Expires=Sun, 08 Aug 2076 19:00:00 GMT; Path=/",
+        "city=Tokyo; Domain=rubyforge.org; Expires=Sun, 08 Aug 2076 19:00:00 GMT; Path=/",
+      ].join(', ')
+
+      cookies = @jar.parse(set_cookie, 'http://rubyforge.org/')
+      assert_equal %w[Akinori Japan Tokyo], cookies.map { |c| c.value }
+      assert_equal %w[Tokyo Japan Akinori], @jar.to_a.sort_by { |c| c.name }.map { |c| c.value }
+    end
+
+    def test_parse_with_block
+      set_cookie = [
+        "name=Akinori; Domain=rubyforge.org; Expires=Sun, 08 Aug 2076 19:00:00 GMT; Path=/",
+        "country=Japan; Domain=rubyforge.org; Expires=Sun, 08 Aug 2076 19:00:00 GMT; Path=/",
+        "city=Tokyo; Domain=rubyforge.org; Expires=Sun, 08 Aug 2076 19:00:00 GMT; Path=/",
+      ].join(', ')
+
+      cookies = @jar.parse(set_cookie, 'http://rubyforge.org/') { |c| c.name != 'city' }
+      assert_equal %w[Akinori Japan], cookies.map { |c| c.value }
+      assert_equal %w[Japan Akinori], @jar.to_a.sort_by { |c| c.name }.map { |c| c.value }
+    end
   end
 
   class WithHashStore < Test::Unit::TestCase

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http-cookie
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre10
+  version: 1.0.0.pre11
 platform: ruby
 authors:
 - Akinori MUSHA
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-07 00:00:00.000000000 Z
+date: 2013-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: domain_name
@@ -132,6 +132,7 @@ files:
 - http-cookie.gemspec
 - lib/http-cookie.rb
 - lib/http/cookie.rb
+- lib/http/cookie/ruby_compat.rb
 - lib/http/cookie/scanner.rb
 - lib/http/cookie/version.rb
 - lib/http/cookie_jar.rb