cookiejar 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e74c8690174e08cec5fa35868f2d91c4428b77d
-  data.tar.gz: aab937a1668a87baa131e048b7fc8d3513bb9d47
+  metadata.gz: 5aba395a725f02d0c68ab3f4b306af071ed2546e
+  data.tar.gz: 138fc4cde85d20a2f820d94136aefec9465491f2
 SHA512:
-  metadata.gz: b84ac2103a3a7435082647d671ae43c2c41b523c09f6563c8f9946613ae00a61c4de70290f3af4b901736333106cf6066ab46fa0e3f4c5fc1b386873b7c9ab26
-  data.tar.gz: fe140117a6960848e4b69697b7368d9ace9abec4edffeb4123c7aaa55392b666d9260097d11bee50bdbe0ff3b7ffbaeef26557925aacb9bd4b7110eee3b002a6
+  metadata.gz: 2b2866097c73852e924c2676f1fe71e5878832f282f9735b340789b9ee4fcf24f1031fe3cdce979be21e2f411dd268bc81fd7702d7ae75a17ea452579f7de08f
+  data.tar.gz: 3d8f17b5d837b3ce5e0f00726875509589a9628b66b240deec90e17a899cdbcb3bfcd08565d16c3ac953759bd973dfb7bc6c75b2588927466a691c43f1fd32c7

data/.gitignore

@@ -0,0 +1,7 @@
+.yardoc
+*.*proj
+pkg
+doc
+.bundle
+.ruby-version
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+-w

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+sudo: false
+cache: bundler
+rvm:
+ - 2.3.0
+ - 2.2.0
+ - 2.1.5
+ - 2.1.4
+ - 2.1.3
+ - 2.1.2
+ - 2.0.0
+ - jruby-19mode
+ - rbx
+jdk:
+ - oraclejdk8
+
+before_install: gem install bundler -v ">=1.9.3"

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/README.markdown

@@ -5,6 +5,8 @@ Ruby CookieJar
 
   **Author**:	David Waite 
 
+[![Build Status](https://travis-ci.org/dwaite/cookiejar.svg?branch=master)](https://travis-ci.org/dwaite/cookiejar)
+
 Synopsis
 --------
 
@@ -12,6 +14,18 @@ The Ruby CookieJar is a library to help manage client-side cookies in pure Ruby.
 
 Both Netscape/RFC 2109 cookies and RFC 2965 cookies are supported.
 
+Roadmap
+-------
+
+For the Next major release, I would like to accomplish:
+
+1. Check against [RFC 6265 - HTTP State Management Mechanism][rfc6265], the latest cookie spec which came out after the initial release of cookiejar
+2. Determine better code structure to encourage alternate persistence mechanisms for cookie jars
+
+[rfc6265]: http://tools.ietf.org/html/rfc6265
 COPYRIGHT
 ---------
-The Ruby CookieJar is Copyright © 2009 David Waite. Licensing terms are given within the LICENSE file.
+The Ruby CookieJar is Copyright © 2009-2014 David Waite, with [additional contributions from various authors][contributions]. Licensing terms are given within the [LICENSE file][LICENSE].
+
+[contributions]: ./contributors.json
+[LICENSE]: ./LICENSE

data/Rakefile

@@ -1,19 +1,15 @@
+require 'bundler/gem_tasks'
+
 require 'rake'
 
 require 'rake/clean'
-require 'rake/packagetask'
 require 'yard'
 require 'yard/rake/yardoc_task'
 
-require 'fileutils'
-include FileUtils
-
-# Default Rake task is to run all tests
-task :default => :test
 CLEAN << Rake::FileList['doc/**', '.yardoc']
-#Yard
+# Yard
 YARD::Rake::YardocTask.new do |t|
-  t.files   = ['lib/**/*.rb']   # optional
+  t.files   = ['lib/**/*.rb'] # optional
   t.options = ['--title', 'CookieJar, a HTTP Client Cookie Parsing Library',
                '--main', 'README.markdown', '--files', 'LICENSE']
 end
@@ -22,10 +18,13 @@ begin
   require 'rspec/core/rake_task'
 
   RSpec::Core::RakeTask.new do |t|
-#    t.libs << 'lib'
-#    t.pattern = 'test/**/*_test.rb'
+    t.ruby_opts = %w(-w)
+    t.pattern = 'spec/**/*_spec.rb'
   end
-  task :test => :spec
+  task test: :spec
 rescue LoadError
-  puts "Warning: unable to load rspec tasks"
+  puts 'Warning: unable to load rspec tasks'
 end
+
+# Default Rake task is to run all tests
+task default: :test

data/cookiejar.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cookiejar/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'cookiejar'
+  s.version     = CookieJar::VERSION
+  s.authors     = ['David Waite']
+  s.email       = ['david@alkaline-solutions.com']
+  s.description = 'Allows for parsing and returning cookies in Ruby HTTP client code'
+  s.summary     = 'Client-side HTTP Cookie library'
+  s.homepage    = 'http://alkaline-solutions.com'
+  s.date        = '2014-02-01'
+
+  s.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  s.test_files    = s.files.grep(%r{^(spec)/})
+  s.rdoc_options  = ['--title', 'CookieJar -- Client-side HTTP Cookies']
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rspec-collection_matchers', '~> 1.0'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'yard',  '~> 0.8', '>= 0.8.7'
+  s.add_development_dependency 'bundler', '>= 0.9.3'
+end

data/lib/cookiejar.rb

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

data/lib/cookiejar/cookie.rb

@@ -3,14 +3,12 @@ require 'uri'
 require 'cookiejar/cookie_validation'
 
 module CookieJar
-
   # Cookie is an immutable object which defines the data model of a HTTP Cookie.
   # The data values within the cookie may be different from the
   # values described in the literal cookie declaration.
   # 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
-
     # [String] The name of the cookie.
     attr_reader :name
     # [String] The value of the cookie, without any attempts at decoding.
@@ -68,15 +66,15 @@ module CookieJar
     #
     # @param [Time] time to compare against, or 'now' if omitted
     # @return [Boolean]
-    def expired? (time = Time.now)
-      expires_at != nil && time > expires_at
+    def expired?(time = Time.now)
+      !expires_at.nil? && time > expires_at
     end
 
     # Indicates whether the cookie will be considered invalid after the end
     # of the current user session
     # @return [Boolean]
     def session?
-      @expiry == nil || @discard
+      @expiry.nil? || @discard
     end
 
     # Create a cookie based on an absolute URI and the string value of a
@@ -88,12 +86,12 @@ module CookieJar
     # @param set_cookie_value [String] HTTP value for the Set-Cookie header.
     # @return [Cookie] created from the header string and request URI
     # @raise [InvalidCookieError] on validation failure(s)
-    def self.from_set_cookie request_uri, set_cookie_value
+    def self.from_set_cookie(request_uri, set_cookie_value)
       args = CookieJar::CookieValidation.parse_set_cookie set_cookie_value
-      args[:domain] = CookieJar::CookieValidation.
-                        determine_cookie_domain request_uri, args[:domain]
-      args[:path] = CookieJar::CookieValidation.
-                        determine_cookie_path request_uri, args[:path]
+      args[:domain] = CookieJar::CookieValidation
+                      .determine_cookie_domain request_uri, args[:domain]
+      args[:path] = CookieJar::CookieValidation
+                    .determine_cookie_path request_uri, args[:path]
       cookie = Cookie.new args
       CookieJar::CookieValidation.validate_cookie request_uri, cookie
       cookie
@@ -108,12 +106,12 @@ module CookieJar
     # @param set_cookie_value [String] HTTP value for the Set-Cookie2 header.
     # @return [Cookie] created from the header string and request URI
     # @raise [InvalidCookieError] on validation failure(s)
-    def self.from_set_cookie2 request_uri, set_cookie_value
+    def self.from_set_cookie2(request_uri, set_cookie_value)
       args = CookieJar::CookieValidation.parse_set_cookie2 set_cookie_value
-      args[:domain] = CookieJar::CookieValidation.
-                        determine_cookie_domain request_uri, args[:domain]
-      args[:path] = CookieJar::CookieValidation.
-                        determine_cookie_path request_uri, args[:path]
+      args[:domain] = CookieJar::CookieValidation
+                      .determine_cookie_domain request_uri, args[:domain]
+      args[:path] = CookieJar::CookieValidation
+                    .determine_cookie_path request_uri, args[:path]
       cookie = Cookie.new args
       CookieJar::CookieValidation.validate_cookie request_uri, cookie
       cookie
@@ -125,45 +123,37 @@ module CookieJar
     #   RFC2965-style.
     # @param [Boolean] true prefix, for RFC2965, whether to prefix with
     # "$Version=<version>;". Ignored for Netscape-style cookies
-    def to_s ver=0, prefix=true
-      case ver
-      when 0
-        "#{name}=#{value}"
-      when 1
-        # we do not need to encode path; the only characters required to be
-        # quoted must be escaped in URI
-        str = prefix ? "$Version=#{version};" : ""
-        str << "#{name}=#{value};$Path=\"#{path}\""
-        if domain.start_with? '.'
-          str << ";$Domain=#{domain}"
-        end
-        if ports
-          str << ";$Port=\"#{ports.join ','}\""
-        end
-        str
-      end
-    end
+    def to_s(ver = 0, prefix = true)
+      return "#{name}=#{value}" if ver == 0
 
+      # we do not need to encode path; the only characters required to be
+      # quoted must be escaped in URI
+      str = prefix ? "$Version=#{version};" : ''
+      str << "#{name}=#{value};$Path=\"#{path}\""
+      str << ";$Domain=#{domain}" if domain.start_with? '.'
+      str << ";$Port=\"#{ports.join ','}\"" if ports
+      str
+    end
 
     # Return a hash representation of the cookie.
 
     def to_hash
       result = {
-        :name => @name,
-        :value => @value,
-        :domain => @domain,
-        :path => @path,
-        :created_at => @created_at
+        name: @name,
+        value: @value,
+        domain: @domain,
+        path: @path,
+        created_at: @created_at
       }
       {
-        :expiry => @expiry,
-        :secure => (true if @secure),
-        :http_only => (true if @http_only),
-        :version => (@version if version != 0),
-        :comment => @comment,
-        :comment_url => @comment_url,
-        :discard => (true if @discard),
-        :ports => @ports
+        expiry: @expiry,
+        secure: (true if @secure),
+        http_only: (true if @http_only),
+        version: (@version if version != 0),
+        comment: @comment,
+        comment_url: @comment_url,
+        discard: (true if @discard),
+        ports: @ports
       }.each do |name, value|
         result[name] = value if value
       end
@@ -181,12 +171,17 @@ module CookieJar
     # @param script [Boolean] indicates that cookies with the 'httponly'
     # extension should be ignored
     # @return [Boolean] whether this cookie should be sent to the server
-    def should_send? request_uri, script
+    def should_send?(request_uri, script)
       uri = CookieJar::CookieValidation.to_uri request_uri
       # cookie path must start with the uri, it must not be a secure cookie
       # being sent over http, and it must not be a http_only cookie sent to
       # a script
-      path_match   = uri.path.start_with? @path
+      path = if uri.path == ''
+               '/'
+             else
+               uri.path
+      end
+      path_match   = path.start_with? @path
       secure_match = !(@secure && uri.scheme == 'http')
       script_match = !(script && @http_only)
       expiry_match = !expired?
@@ -195,7 +190,7 @@ module CookieJar
     end
 
     def decoded_value
-      CookieJar::CookieValidation::decode_value value
+      CookieJar::CookieValidation.decode_value value
     end
 
     # Return a JSON 'object' for the various data values. Allows for
@@ -204,8 +199,8 @@ module CookieJar
     # @param [Array] a options controlling output JSON text
     #   (usually a State and a depth)
     # @return [String] JSON representation of object data
-    def to_json *a
-      to_hash.merge(:json_class => self.class.name).to_json(*a)
+    def to_json(*a)
+      to_hash.merge(json_class: self.class.name).to_json(*a)
     end
 
     # Given a Hash representation of a JSON document, create a local cookie
@@ -213,7 +208,7 @@ module CookieJar
     #
     # @param [Hash] o JSON object of array data
     # @return [Cookie] cookie formed from JSON data
-    def self.json_create o
+    def self.json_create(o)
       params = o.inject({}) do |hash, (key, value)|
         hash[key.to_sym] = value
         hash
@@ -227,7 +222,7 @@ module CookieJar
       end
       params.delete :expiry
 
-      self.new params
+      new params
     end
 
     # Compute the cookie search domains for a given request URI
@@ -236,28 +231,27 @@ module CookieJar
     #
     # @param request_uri [String, URI] address being requested
     # @return [Array<String>] String domain matches
-    def self.compute_search_domains request_uri
+    def self.compute_search_domains(request_uri)
       CookieValidation.compute_search_domains request_uri
     end
-  protected
-    # Call {from_set_cookie} to create a new Cookie instance
-    def initialize args
 
+    protected
+
+    # Call {from_set_cookie} to create a new Cookie instance
+    def initialize(args)
       @created_at, @name, @value, @domain, @path, @secure,
       @http_only, @version, @comment, @comment_url, @discard, @ports \
       = args.values_at \
-      :created_at, :name, :value, :domain, :path, :secure,
-      :http_only, :version, :comment, :comment_url, :discard, :ports
+        :created_at, :name, :value, :domain, :path, :secure,
+        :http_only, :version, :comment, :comment_url, :discard, :ports
 
       @created_at ||= Time.now
-      @expiry     = args[:max_age]   || args[:expires_at]
+      @expiry = args[:max_age] || args[:expires_at]
       @secure     ||= false
       @http_only  ||= false
       @discard    ||= false
 
-      if @ports.is_a? Integer
-        @ports = [@ports]
-      end
+      @ports = [@ports] if @ports.is_a? Integer
     end
   end
 end

data/lib/cookiejar/cookie_validation.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
 require 'cgi'
 require 'uri'
+
 module CookieJar
   # Represents a set of cookie validation errors
   class InvalidCookieError < StandardError
@@ -8,37 +10,37 @@ module CookieJar
 
     # Create a new instance
     # @param [String, Array<String>] the validation issue(s) encountered
-    def initialize message
-     if message.is_a? Array
-       @messages = message
-       message = message.join ', '
-     else
-       @messages = [message]
-     end
-     super message
+    def initialize(message)
+      if message.is_a? Array
+        @messages = message
+        message = message.join ', '
+      else
+        @messages = [message]
+      end
+      super message
     end
   end
 
   # Contains logic to parse and validate cookie headers
   module CookieValidation
+    # REGEX cookie matching
     module PATTERN
       include URI::REGEXP::PATTERN
 
-      TOKEN = '[^(),\/<>@;:\\\"\[\]?={}\s]+'
-      VALUE1 = "([^;]*)"
-      IPADDR = "#{IPV4ADDR}|#{IPV6ADDR}"
-      BASE_HOSTNAME = "(?:#{DOMLABEL}\\.)(?:((?:(?:#{DOMLABEL}\\.)+(?:#{TOPLABEL}\\.?))|local))"
+      TOKEN = '[^(),\/<>@;:\\\"\[\]?={}\s]+'.freeze
+      VALUE1 = '([^;]*)'.freeze
+      IPADDR = "#{IPV4ADDR}|#{IPV6ADDR}".freeze
+      BASE_HOSTNAME = "(?:#{DOMLABEL}\\.)(?:((?:(?:#{DOMLABEL}\\.)+(?:#{TOPLABEL}\\.?))|local))".freeze
 
-      QUOTED_PAIR = "\\\\[\\x00-\\x7F]"
-      LWS = "\\r\\n(?:[ \\t]+)"
+      QUOTED_PAIR = '\\\\[\\x00-\\x7F]'.freeze
+      LWS = '\\r\\n(?:[ \\t]+)'.freeze
       # 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}"
-
+      QDTEXT = "[\\t\\x20-\\x21\\x23-\\x7E\\x80-\\xFF]|(?:#{LWS})".freeze
+      QUOTED_TEXT = "\\\"(?:#{QDTEXT}|#{QUOTED_PAIR})*\\\"".freeze
+      VALUE2 = "#{TOKEN}|#{QUOTED_TEXT}".freeze
     end
     BASE_HOSTNAME = /#{PATTERN::BASE_HOSTNAME}/
-    BASE_PATH = /\A((?:[^\/?#]*\/)*)/
+    BASE_PATH = %r{\A((?:[^/?#]*/)*)}
     IPADDR = /\A#{PATTERN::IPV4ADDR}\Z|\A#{PATTERN::IPV6ADDR}\Z/
     HDN = /\A#{PATTERN::HOSTNAME}\Z/
     TOKEN = /\A#{PATTERN::TOKEN}\Z/
@@ -50,8 +52,8 @@ module CookieJar
     #
     # @param [String, URI] request_uri URI we are normalizing
     # @param [URI] URI representation of input string, or original URI
-    def self.to_uri request_uri
-      (request_uri.is_a? URI)? request_uri : (URI.parse request_uri)
+    def self.to_uri(request_uri)
+      (request_uri.is_a? URI) ? request_uri : (URI.parse request_uri)
     end
 
     # Converts an input cookie or uri to a string representing the path.
@@ -59,7 +61,7 @@ module CookieJar
     #
     # @param [String, URI, Cookie] object containing the path
     # @return [String] path information
-    def self.to_path uri_or_path
+    def self.to_path(uri_or_path)
       if (uri_or_path.is_a? URI) || (uri_or_path.is_a? Cookie)
         uri_or_path.path
       else
@@ -72,7 +74,7 @@ module CookieJar
     #
     # @param [String, URI, Cookie] object containing the domain
     # @return [String] domain information.
-    def self.to_domain uri_or_domain
+    def self.to_domain(uri_or_domain)
       if uri_or_domain.is_a? URI
         uri_or_domain.host
       elsif uri_or_domain.is_a? Cookie
@@ -88,10 +90,10 @@ module CookieJar
     # @param [String] tested_domain domain to be tested against
     # @param [String] base_domain new domain being tested
     # @return [String,nil] matching domain on success, nil on failure
-    def self.domains_match tested_domain, base_domain
+    def self.domains_match(tested_domain, base_domain)
       base = effective_host base_domain
       search_domains = compute_search_domains_for_host base
-      result = search_domains.find do |domain|
+      search_domains.find do |domain|
         domain == tested_domain
       end
     end
@@ -101,21 +103,19 @@ module CookieJar
     #
     # @param [String,URI,Cookie] hostname hostname, or object holding hostname
     # @return [String,nil] next highest hostname, or nil if none
-    def self.hostname_reach hostname
+    def self.hostname_reach(hostname)
       host = to_domain hostname
       host = host.downcase
       match = BASE_HOSTNAME.match host
-      if match
-        match[1]
-      end
+      match[1] if match
     end
 
     # Compute the base of a path, for default cookie path assignment
     #
     # @param [String, URI, Cookie] path, or object holding path
     # @return base path (all characters up to final '/')
-    def self.cookie_base_path path
-      BASE_PATH.match(to_path path)[1]
+    def self.cookie_base_path(path)
+      BASE_PATH.match(to_path(path))[1]
     end
 
     # Processes cookie path data using the following rules:
@@ -123,16 +123,16 @@ module CookieJar
     # 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
+    # Note that this will not attempt to detect a mismatch of the request uri
+    # domain and explicitly specified cookie path
     #
     # @param [String,URI] request URI yielding this cookie
     # @param [String] path on cookie
-    def self.determine_cookie_path request_uri, cookie_path
+    def self.determine_cookie_path(request_uri, cookie_path)
       uri = to_uri request_uri
       cookie_path = to_path cookie_path
 
-      if cookie_path == nil || cookie_path.empty?
+      if cookie_path.nil? || cookie_path.empty?
         cookie_path = cookie_base_path uri.path
       end
       cookie_path
@@ -145,8 +145,9 @@ module CookieJar
     # @param [String, URI] request_uri requested uri
     # @return [Array<String>] all cookie domain values which would match the
     #   requested uri
-    def self.compute_search_domains request_uri
+    def self.compute_search_domains(request_uri)
       uri = to_uri request_uri
+      return nil unless uri.is_a? URI::HTTP
       host = uri.host
       compute_search_domains_for_host host
     end
@@ -157,59 +158,55 @@ module CookieJar
     # @param [String] host host being requested
     # @return [Array<String>] all cookie domain values which would match the
     #   requested uri
-    def self.compute_search_domains_for_host host
+    def self.compute_search_domains_for_host(host)
       host = effective_host host
       result = [host]
       unless host =~ IPADDR
         result << ".#{host}"
         base = hostname_reach host
-        if base
-          result << ".#{base}"
-        end
+        result << ".#{base}" if 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.
+    # 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.
+    # 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
+    # Note that this will not attempt to detect a mismatch of the request uri
+    # domain and explicitly specified cookie domain
     #
     # @param [String, URI] request_uri originally requested URI
     # @param [String] cookie domain value
     # @return [String] effective host
-    def self.determine_cookie_domain request_uri, cookie_domain
+    def self.determine_cookie_domain(request_uri, cookie_domain)
       uri = to_uri request_uri
       domain = to_domain cookie_domain
 
-      if domain == nil || domain.empty?
-        domain = effective_host uri.host
+      return effective_host(uri.host) if domain.nil? || domain.empty?
+      domain = domain.downcase
+      if domain =~ IPADDR || domain.start_with?('.')
+        domain
       else
-        domain = domain.downcase
-        if domain =~ IPADDR || domain.start_with?('.')
-          domain
-        else
-          ".#{domain}"
-        end
+        ".#{domain}"
       end
     end
 
     # Compute the effective host (RFC 2965, section 1)
     #
-    # Has the added additional logic of searching for interior dots specifically, and
-    # matches colons to prevent .local being suffixed on IPv6 addresses
+    # Has the added additional logic of searching for interior dots
+    # specifically, and matches colons to prevent .local being suffixed on
+    # IPv6 addresses
     #
     # @param [String, URI] host_or_uridomain name, or absolute URI
     # @return [String] effective host per RFC rules
-    def self.effective_host host_or_uri
+    def self.effective_host(host_or_uri)
       hostname = to_domain host_or_uri
       hostname = hostname.downcase
 
@@ -227,11 +224,9 @@ module CookieJar
     # @param [Cookie] cookie object
     # @param [true] will always return true on success
     # @raise [InvalidCookieError] on failures, containing all validation errors
-    def self.validate_cookie request_uri, cookie
+    def self.validate_cookie(request_uri, cookie)
       uri = to_uri request_uri
-      request_host = effective_host uri.host
       request_path = uri.path
-      request_secure = (uri.scheme == 'https')
       cookie_host = cookie.domain
       cookie_path = cookie.path
 
@@ -242,19 +237,22 @@ module CookieJar
       # A user agent rejects (SHALL NOT store its information) if the
       # Version attribute is missing. Note that the legacy Set-Cookie
       # directive will result in an implicit version 0.
-      unless cookie.version
-        errors << "Version missing"
-      end
+      errors << 'Version missing' unless cookie.version
 
       # The value for the Path attribute is not a prefix of the request-URI
+
+      # If the initial request path is empty then this will always fail
+      # so check if it is empty and if so then set it to /
+      request_path = '/' if request_path == ''
+
       unless request_path.start_with? cookie_path
-        errors << "Path is not a prefix of the request uri path"
+        errors << 'Path is not a prefix of the request uri path'
       end
 
-      unless cookie_host =~ IPADDR || #is an IPv4 or IPv6 address
-        cookie_host =~ /.\../ || #contains an embedded dot
-        cookie_host == '.local' #is the domain cookie for local addresses
-        errors << "Domain format is illegal"
+      unless cookie_host =~ IPADDR || # is an IPv4 or IPv6 address
+             cookie_host =~ /.\../ || # contains an embedded dot
+             cookie_host == '.local' # is the domain cookie for local addresses
+        errors << 'Domain format is illegal'
       end
 
       # The effective host name that derives from the request-host does
@@ -264,18 +262,18 @@ module CookieJar
       # where D is the value of the Domain attribute, and H is a string
       # that contains one or more dots.
       unless domains_match cookie_host, uri
-        errors << "Domain is inappropriate based on request URI hostname"
+        errors << 'Domain is inappropriate based on request URI hostname'
       end
 
       # The Port attribute has a "port-list", and the request-port was
       # not in the list.
-      unless cookie.ports.nil? || cookie.ports.length != 0
+      unless cookie.ports.nil? || !cookie.ports.empty?
         unless cookie.ports.find_index uri.port
-          errors << "Ports list does not contain request URI port"
+          errors << 'Ports list does not contain request URI port'
         end
       end
 
-      raise InvalidCookieError.new(errors) unless errors.empty?
+      fail InvalidCookieError, 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
@@ -289,15 +287,16 @@ module CookieJar
     # @param [String] set_cookie_value a Set-Cookie header formatted cookie
     #   definition
     # @return [Hash] Contains the parsed values of the cookie
-    def self.parse_set_cookie set_cookie_value
-      args = { }
-      params=set_cookie_value.split(/;\s*/)
+    def self.parse_set_cookie(set_cookie_value)
+      args = {}
+      params = set_cookie_value.split(/;\s*/)
 
-      first=true
+      first = true
       params.each do |param|
         result = PARAM1.match param
-        if !result
-          raise InvalidCookieError.new "Invalid cookie parameter in cookie '#{set_cookie_value}'"
+        unless result
+          fail InvalidCookieError,
+               "Invalid cookie parameter in cookie '#{set_cookie_value}'"
         end
         key = result[1].downcase.to_sym
         keyvalue = result[2]
@@ -311,17 +310,19 @@ module CookieJar
             begin
               args[:expires_at] = Time.parse keyvalue
             rescue ArgumentError
-              raise unless $!.message == "time out of range"
+              raise unless $ERROR_INFO.message == 'time out of range'
               args[:expires_at] = Time.at(0x7FFFFFFF)
             end
-          when *[:domain, :path]
+          when :"max-age"
+            args[:max_age] = keyvalue.to_i
+          when :domain, :path
             args[key] = keyvalue
           when :secure
             args[:secure] = true
           when :httponly
             args[:http_only] = true
           else
-            raise InvalidCookieError.new "Unknown cookie parameter '#{key}'"
+            fail InvalidCookieError, "Unknown cookie parameter '#{key}'"
           end
         end
       end
@@ -330,18 +331,18 @@ module CookieJar
     end
 
     # Parse a RFC 2965 value and convert to a literal string
-    def self.value_to_string value
-      if /\A"(.*)"\Z/.match value
-        value = $1
-        value = value.gsub(/\\(.)/, '\1')
+    def self.value_to_string(value)
+      if /\A"(.*)"\Z/ =~ value
+        value = Regexp.last_match(1)
+        value.gsub(/\\(.)/, '\1')
       else
         value
       end
     end
 
     # Attempt to decipher a partially decoded version of text cookie values
-    def self.decode_value value
-      if /\A"(.*)"\Z/.match value
+    def self.decode_value(value)
+      if /\A"(.*)"\Z/ =~ value
         value_to_string value
       else
         CGI.unescape value
@@ -355,16 +356,17 @@ module CookieJar
     # @param [String] set_cookie_value a Set-Cookie2 header formatted cookie
     #   definition
     # @return [Hash] Contains the parsed values of the cookie
-    def self.parse_set_cookie2 set_cookie_value
-      args = { }
+    def self.parse_set_cookie2(set_cookie_value)
+      args = {}
       first = true
       index = 0
       begin
         md = PARAM2.match set_cookie_value[index..-1]
         if md.nil? || md.offset(0).first != 0
-          raise InvalidCookieError.new "Invalid Set-Cookie2 header '#{set_cookie_value}'"
+          fail InvalidCookieError,
+               "Invalid Set-Cookie2 header '#{set_cookie_value}'"
         end
-        index+=md.offset(0)[1]
+        index += md.offset(0)[1]
 
         key = md[1].downcase.to_sym
         keyvalue = md[2] || md[3]
@@ -375,9 +377,9 @@ module CookieJar
         else
           keyvalue = value_to_string keyvalue
           case key
-          when *[:comment,:commenturl,:domain,:path]
+          when :comment, :commenturl, :domain, :path
             args[key] = keyvalue
-          when *[:discard,:secure]
+          when :discard, :secure
             args[key] = true
           when :httponly
             args[:http_only] = true
@@ -388,15 +390,16 @@ module CookieJar
           when :port
             # must be in format '"port,port"'
             ports = keyvalue.split(/,\s*/)
-            args[:ports] = ports.map do |portstr| portstr.to_i end
+            args[:ports] = ports.map(&:to_i)
           else
-            raise InvalidCookieError.new "Unknown cookie parameter '#{key}'"
+            fail InvalidCookieError, "Unknown cookie parameter '#{key}'"
           end
         end
       end until md.post_match.empty?
       # if our last match in the scan failed
       if args[:version] != 1
-        raise InvalidCookieError.new "Set-Cookie2 declares a non RFC2965 version cookie"
+        fail InvalidCookieError,
+             'Set-Cookie2 declares a non RFC2965 version cookie'
       end
 
       args