cookiejar 0.3.2 → 0.3.3

data/lib/cookiejar/jar.rb

@@ -56,7 +56,7 @@ module CookieJar
     # @param [String] cookie_header_value the contents of the Set-Cookie
     # @return [Cookie] which was created and stored
     # @raise [InvalidCookieError] if the cookie header did not validate
-    def set_cookie request_uri, cookie_header_values
+    def set_cookie(request_uri, cookie_header_values)
       cookie_header_values.split(/, (?=[\w]+=)/).each do |cookie_header_value|
         cookie = Cookie.from_set_cookie request_uri, cookie_header_value
         add_cookie cookie
@@ -70,7 +70,7 @@ module CookieJar
     # @param [String] cookie_header_value the contents of the Set-Cookie2
     # @return [Cookie] which was created and stored
     # @raise [InvalidCookieError] if the cookie header did not validate
-    def set_cookie2 request_uri, cookie_header_value
+    def set_cookie2(request_uri, cookie_header_value)
       cookie = Cookie.from_set_cookie2 request_uri, cookie_header_value
       add_cookie cookie
     end
@@ -87,7 +87,7 @@ module CookieJar
     # @return [Array<Cookie>,nil] the cookies created, or nil if none found.
     # @raise [InvalidCookieError] if one of the cookie headers contained
     #   invalid formatting or data
-    def set_cookies_from_headers request_uri, http_headers
+    def set_cookies_from_headers(request_uri, http_headers)
       set_cookie_key = http_headers.keys.detect { |k| /\ASet-Cookie\Z/i.match k }
       cookies = gather_header_values http_headers[set_cookie_key] do |value|
         begin
@@ -123,7 +123,7 @@ module CookieJar
     #
     # @param [Cookie] cookie a pre-existing cookie object
     # @return [Cookie] the cookie added to the store
-    def add_cookie cookie
+    def add_cookie(cookie)
       domain_paths = find_or_add_domain_for_cookie cookie
       add_cookie_to_path domain_paths, cookie
       cookie
@@ -149,7 +149,7 @@ 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
+    def to_json(*a)
       {
         'json_class' => self.class.name,
         'cookies' => to_a.to_json(*a)
@@ -160,17 +160,13 @@ module CookieJar
     #
     # @param o [Hash] the expanded JSON object
     # @return [CookieJar] a new CookieJar instance
-    def self.json_create o
-      if o.is_a? String
-        o = JSON.parse(o)
-      end
-      if o.is_a? Hash
-        o = o['cookies']
-      end
+    def self.json_create(o)
+      o = JSON.parse(o) if o.is_a? String
+      o = o['cookies'] if o.is_a? Hash
       cookies = o.inject([]) do |result, cookie_json|
         result << (Cookie.json_create cookie_json)
       end
-      self.from_a cookies
+      from_a cookies
     end
 
     # Create a new Jar from an array of Cookie objects. Expired cookies
@@ -179,7 +175,7 @@ module CookieJar
     #
     # @param [Array<Cookie>] cookies array of cookie objects
     # @return [CookieJar] a new CookieJar instance
-    def self.from_a cookies
+    def self.from_a(cookies)
       jar = new
       cookies.each do |cookie|
         jar.add_cookie cookie
@@ -192,10 +188,10 @@ module CookieJar
     #
     # @param session [Boolean] whether session cookies should be expired,
     #   or just cookies past their expiration date.
-    def expire_cookies session = false
-      @domains.delete_if do |domain, paths|
-        paths.delete_if do |path, cookies|
-          cookies.delete_if do |cookie_name, cookie|
+    def expire_cookies(session = false)
+      @domains.delete_if do |_domain, paths|
+        paths.delete_if do |_path, cookies|
+          cookies.delete_if do |_cookie_name, cookie|
             cookie.expired? || (session && cookie.session?)
           end
           cookies.empty?
@@ -209,27 +205,36 @@ module CookieJar
     # otherwise unordered.
     #
     # @param [String, URI] request_uri the address the HTTP request will be
-    #   sent to
+    #   sent to. This must be a full URI, i.e. must include the protocol,
+    #   if you pass digi.ninja it will fail to find the domain, you must pass
+    #   http://digi.ninja
     # @param [Hash] opts options controlling returned cookies
-    # @option opts [Boolean] :script (false) Cookies marked HTTP-only will be ignored
-    #   if true
+    # @option opts [Boolean] :script (false) Cookies marked HTTP-only will be
+    #   ignored if true
     # @return [Array<Cookie>] cookies which should be sent in the HTTP request
-    def get_cookies request_uri, opts = { }
+    def get_cookies(request_uri, opts = {})
       uri = to_uri request_uri
       hosts = Cookie.compute_search_domains uri
 
+      return [] if hosts.nil?
+
+      path = if uri.path == ''
+               '/'
+             else
+               uri.path
+      end
+
       results = []
       hosts.each do |host|
         domain = find_domain host
-        domain.each do |path, cookies|
-          if uri.path.start_with? path
-            results += cookies.values.select do |cookie|
-              cookie.should_send? uri, opts[:script]
-            end
+        domain.each do |apath, cookies|
+          next unless path.start_with? apath
+          results += cookies.values.select do |cookie|
+            cookie.should_send? uri, opts[:script]
           end
         end
       end
-      #Sort by path length, longest first
+      # Sort by path length, longest first
       results.sort do |lhs, rhs|
         rhs.path.length <=> lhs.path.length
       end
@@ -242,22 +247,19 @@ module CookieJar
     # @param [String, URI] request_uri the address the HTTP request will be
     #   sent to
     # @param [Hash] opts options controlling returned cookies
-    # @option opts [Boolean] :script (false) Cookies marked HTTP-only will be ignored
-    #   if true
+    # @option opts [Boolean] :script (false) Cookies marked HTTP-only will be
+    #   ignored if true
     # @return String value of the Cookie header which should be sent on the
     #   HTTP request
-    def get_cookie_header request_uri, opts = { }
+    def get_cookie_header(request_uri, opts = {})
       cookies = get_cookies request_uri, opts
-      version = 0
-      ver = [[],[]]
+      ver = [[], []]
       cookies.each do |cookie|
         ver[cookie.version] << cookie
       end
-      if (ver[1].empty?)
+      if ver[1].empty?
         # can do a netscape-style cookie header, relish the opportunity
-        cookies.map do |cookie|
-          cookie.to_s
-        end.join ";"
+        cookies.map(&:to_s).join ';'
       else
         # build a RFC 2965-style cookie header. Split the cookies into
         # version 0 and 1 groups so that we can reuse the '$Version' header
@@ -265,46 +267,46 @@ module CookieJar
         unless ver[0].empty?
           result << '$Version=0;'
           result << ver[0].map do |cookie|
-            (cookie.to_s 1,false)
+            (cookie.to_s 1, false)
           end.join(';')
           # separate version 0 and 1 with a comma
           result << ','
         end
         result << '$Version=1;'
         ver[1].map do |cookie|
-          result << (cookie.to_s 1,false)
+          result << (cookie.to_s 1, false)
         end
         result
       end
     end
 
-  protected
+    protected
 
-    def gather_header_values http_header_value, &block
+    def gather_header_values(http_header_value, &_block)
       result = []
       if http_header_value.is_a? Array
         http_header_value.each do |value|
-          result << block.call(value)
+          result << yield(value)
         end
       elsif http_header_value.is_a? String
-        result << block.call(http_header_value)
+        result << yield(http_header_value)
       end
       result.compact
     end
 
-    def to_uri request_uri
-      (request_uri.is_a? URI)? request_uri : (URI.parse request_uri)
+    def to_uri(request_uri)
+      (request_uri.is_a? URI) ? request_uri : (URI.parse request_uri)
     end
 
-    def find_domain host
+    def find_domain(host)
       @domains[host] || {}
     end
 
-    def find_or_add_domain_for_cookie cookie
+    def find_or_add_domain_for_cookie(cookie)
       @domains[cookie.domain] ||= {}
     end
 
-    def add_cookie_to_path paths, cookie
+    def add_cookie_to_path(paths, cookie)
       path_entry = (paths[cookie.path] ||= {})
       path_entry[cookie.name] = cookie
     end

data/lib/cookiejar/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module CookieJar
+  VERSION = '0.3.3'.freeze
+end

data/spec/cookie_spec.rb

@@ -1,176 +1,176 @@
-require 'cookiejar'
-require 'rubygems'
+# frozen_string_literal: true
+require 'spec_helper'
 
 include CookieJar
 
-FOO_URL = 'http://localhost/foo'
-AMMO_URL = 'http://localhost/ammo'
+FOO_URL = 'http://localhost/foo'.freeze
+AMMO_URL = 'http://localhost/ammo'.freeze
 NETSCAPE_SPEC_SET_COOKIE_HEADERS =
-[['CUSTOMER=WILE_E_COYOTE; path=/; expires=Wednesday, 09-Nov-99 23:12:40 GMT',
+  [['CUSTOMER=WILE_E_COYOTE; path=/; expires=Wednesday, 09-Nov-99 23:12:40 GMT',
     FOO_URL],
-  ['PART_NUMBER=ROCKET_LAUNCHER_0001; path=/',
+   ['PART_NUMBER=ROCKET_LAUNCHER_0001; path=/',
     FOO_URL],
-  ['SHIPPING=FEDEX; path=/foo',
+   ['SHIPPING=FEDEX; path=/foo',
     FOO_URL],
-  ['PART_NUMBER=ROCKET_LAUNCHER_0001; path=/',
+   ['PART_NUMBER=ROCKET_LAUNCHER_0001; path=/',
     FOO_URL],
-  ['PART_NUMBER=RIDING_ROCKET_0023; path=/ammo',
-    AMMO_URL]]
+   ['PART_NUMBER=RIDING_ROCKET_0023; path=/ammo',
+    AMMO_URL]].freeze
 
 describe Cookie do
-  describe "#from_set_cookie" do
-    it "should handle cookies from the netscape spec" do
+  describe '#from_set_cookie' do
+    it 'should handle cookies from the netscape spec' do
       NETSCAPE_SPEC_SET_COOKIE_HEADERS.each do |value|
         header, url = *value
-        cookie = Cookie.from_set_cookie url, header
+        Cookie.from_set_cookie url, header
       end
     end
-    it "should give back the input names and values" do
+    it 'should give back the input names and values' do
       cookie = Cookie.from_set_cookie 'http://localhost/', 'foo=bar'
-      cookie.name.should == 'foo'
-      cookie.value.should == 'bar'
+      expect(cookie.name).to eq 'foo'
+      expect(cookie.value).to eq 'bar'
     end
-    it "should normalize domain names" do
+    it 'should normalize domain names' do
       cookie = Cookie.from_set_cookie 'http://localhost/', 'foo=Bar;domain=LoCaLHoSt.local'
-      cookie.domain.should == '.localhost.local'
+      expect(cookie.domain).to eq '.localhost.local'
     end
-    it "should accept non-normalized .local" do
+    it 'should accept non-normalized .local' do
       cookie = Cookie.from_set_cookie 'http://localhost/', 'foo=bar;domain=.local'
-      cookie.domain.should == '.local'
+      expect(cookie.domain).to eq '.local'
     end
-    it "should accept secure cookies" do
+    it 'should accept secure cookies' do
       cookie = Cookie.from_set_cookie 'https://www.google.com/a/blah', 'GALX=RgmSftjnbPM;Path=/a/;Secure'
-      cookie.name.should == 'GALX'
-      cookie.secure.should be_true
+      expect(cookie.name).to eq 'GALX'
+      expect(cookie.secure).to be_truthy
     end
   end
-  describe "#from_set_cookie2" do
-    it "should give back the input names and values" do
+  describe '#from_set_cookie2' do
+    it 'should give back the input names and values' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'foo=bar;Version=1'
-      cookie.name.should == 'foo'
-      cookie.value.should == 'bar'
+      expect(cookie.name).to eq 'foo'
+      expect(cookie.value).to eq 'bar'
     end
-    it "should normalize domain names" do
+    it 'should normalize domain names' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'foo=Bar;domain=LoCaLHoSt.local;Version=1'
-      cookie.domain.should == '.localhost.local'
+      expect(cookie.domain).to eq '.localhost.local'
     end
-    it "should accept non-normalized .local" do
+    it 'should accept non-normalized .local' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'foo=bar;domain=.local;Version=1'
-      cookie.domain.should == '.local'
+      expect(cookie.domain).to eq '.local'
     end
-    it "should accept secure cookies" do
+    it 'should accept secure cookies' do
       cookie = Cookie.from_set_cookie2 'https://www.google.com/a/blah', 'GALX=RgmSftjnbPM;Path="/a/";Secure;Version=1'
-      cookie.name.should == 'GALX'
-      cookie.path.should == '/a/'
-      cookie.secure.should be_true
+      expect(cookie.name).to eq 'GALX'
+      expect(cookie.path).to eq '/a/'
+      expect(cookie.secure).to be_truthy
     end
-    it "should fail on unquoted paths" do
-      lambda do 
-        Cookie.from_set_cookie2 'https://www.google.com/a/blah', 
-          'GALX=RgmSftjnbPM;Path=/a/;Secure;Version=1'
-      end.should raise_error InvalidCookieError
+    it 'should fail on unquoted paths' do
+      expect(lambda do
+        Cookie.from_set_cookie2 'https://www.google.com/a/blah',
+                                'GALX=RgmSftjnbPM;Path=/a/;Secure;Version=1'
+      end).to raise_error InvalidCookieError
     end
-    it "should accept quoted values" do
+    it 'should accept quoted values' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'foo="bar";Version=1'
-      cookie.name.should == 'foo'
-      cookie.value.should == '"bar"'
+      expect(cookie.name).to eq 'foo'
+      expect(cookie.value).to eq '"bar"'
     end
-    it "should accept poorly chosen names" do
+    it 'should accept poorly chosen names' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'Version=mine;Version=1'
-      cookie.name.should == 'Version'
-      cookie.value.should == 'mine'
+      expect(cookie.name).to eq 'Version'
+      expect(cookie.value).to eq 'mine'
     end
-    it "should accept quoted parameter values" do
-      cookie = Cookie.from_set_cookie2 'http://localhost/', 'foo=bar;Version="1"'
+    it 'should accept quoted parameter values' do
+      Cookie.from_set_cookie2 'http://localhost/', 'foo=bar;Version="1"'
     end
-    it "should honor the discard and max-age parameters" do
+    it 'should honor the discard and max-age parameters' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'f=b;max-age=100;discard;Version=1'
-      cookie.should be_session
-      cookie.should_not be_expired
-      
+      expect(cookie).to be_session
+      expect(cookie).to_not be_expired
+
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'f=b;max-age=100;Version=1'
-      cookie.should_not be_session
+      expect(cookie).to_not be_session
 
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'f=b;Version=1'
-      cookie.should be_session
+      expect(cookie).to be_session
     end
-    it "should handle quotable quotes" do
+    it 'should handle quotable quotes' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'f="\"";Version=1'
-      cookie.value.should eql '"\""'
+      expect(cookie.value).to eq '"\""'
     end
-    it "should handle quotable apostrophes" do
+    it 'should handle quotable apostrophes' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'f="\;";Version=1'
-      cookie.value.should eql '"\;"'
+      expect(cookie.value).to eq '"\;"'
     end
   end
   describe '#decoded_value' do
-    it "should leave normal values alone" do
+    it 'should leave normal values alone' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'f=b;Version=1'
-      cookie.decoded_value.should eql 'b'
+      expect(cookie.decoded_value).to eq 'b'
     end
-    it "should attempt to unencode quoted values" do
+    it 'should attempt to unencode quoted values' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'f="\"b";Version=1'
-      cookie.value.should eql '"\"b"'
-      cookie.decoded_value.should eql '"b'
+      expect(cookie.value).to eq '"\"b"'
+      expect(cookie.decoded_value).to eq '"b'
     end
   end
   describe '#to_s' do
-    it "should handle a simple cookie" do
+    it 'should handle a simple cookie' do
       cookie = Cookie.from_set_cookie 'http://localhost/', 'f=b'
-      cookie.to_s.should == 'f=b'
-      cookie.to_s(1).should == '$Version=0;f=b;$Path="/"'
+      expect(cookie.to_s).to eq 'f=b'
+      expect(cookie.to_s(1)).to eq '$Version=0;f=b;$Path="/"'
     end
-    it "should report an explicit domain" do
+    it 'should report an explicit domain' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'f=b;Version=1;Domain=.local'
-      cookie.to_s(1).should == '$Version=1;f=b;$Path="/";$Domain=.local'
+      expect(cookie.to_s(1)).to eq '$Version=1;f=b;$Path="/";$Domain=.local'
     end
-    it "should return specified ports" do
+    it 'should return specified ports' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'f=b;Version=1;Port="80,443"'
-      cookie.to_s(1).should == '$Version=1;f=b;$Path="/";$Port="80,443"'
+      expect(cookie.to_s(1)).to eq '$Version=1;f=b;$Path="/";$Port="80,443"'
     end
-    it "should handle specified paths" do
+    it 'should handle specified paths' do
       cookie = Cookie.from_set_cookie 'http://localhost/bar/', 'f=b;path=/bar/'
-      cookie.to_s.should == 'f=b'
-      cookie.to_s(1).should == '$Version=0;f=b;$Path="/bar/"'
+      expect(cookie.to_s).to eq 'f=b'
+      expect(cookie.to_s(1)).to eq '$Version=0;f=b;$Path="/bar/"'
     end
-    it "should omit $Version header when asked" do
+    it 'should omit $Version header when asked' do
       cookie = Cookie.from_set_cookie 'http://localhost/', 'f=b'
-      cookie.to_s(1,false).should == 'f=b;$Path="/"'
+      expect(cookie.to_s(1, false)).to eq 'f=b;$Path="/"'
     end
   end
   describe '#should_send?' do
-    it "should not send if ports do not match" do
+    it 'should not send if ports do not match' do
       cookie = Cookie.from_set_cookie2 'http://localhost/', 'f=b;Version=1;Port="80"'
-      cookie.should_send?("http://localhost/", false).should be_true
-      cookie.should_send?("https://localhost/", false).should be_false
+      expect(cookie.should_send?('http://localhost/', false)).to be_truthy
+      expect(cookie.should_send?('https://localhost/', false)).to be_falsey
     end
   end
   begin
     require 'json'
-    describe ".to_json" do
-      it "should serialize a cookie to JSON" do
+    describe '.to_json' do
+      it 'should serialize a cookie to JSON' do
         c = Cookie.from_set_cookie 'https://localhost/', 'foo=bar;secure;expires=Fri, September 11 2009 18:10:00 -0700'
         json = c.to_json
-        json.should be_a String
+        expect(json).to be_a String
       end
     end
-    describe ".json_create" do
-      it "should deserialize JSON to a cookie" do
-        json = "{\"name\":\"foo\",\"value\":\"bar\",\"domain\":\"localhost.local\",\"path\":\"\\/\",\"created_at\":\"2009-09-11 12:51:03 -0600\",\"expiry\":\"2009-09-11 19:10:00 -0600\",\"secure\":true}" 
+    describe '.json_create' do
+      it 'should deserialize JSON to a cookie' do
+        json = '{"name":"foo","value":"bar","domain":"localhost.local","path":"\\/","created_at":"2009-09-11 12:51:03 -0600","expiry":"2009-09-11 19:10:00 -0600","secure":true}'
         hash = JSON.parse json
         c = Cookie.json_create hash
         CookieValidation.validate_cookie 'https://localhost/', c
       end
-      it "should automatically deserialize to a cookie" do
-        json = "{\"json_class\":\"CookieJar::Cookie\",\"name\":\"foo\",\"value\":\"bar\",\"domain\":\"localhost.local\",\"path\":\"\\/\",\"created_at\":\"2009-09-11 12:51:03 -0600\",\"expiry\":\"2009-09-11 19:10:00 -0600\",\"secure\":true}" 
-        c = JSON.parse json, :create_additions => true
-        c.should be_a Cookie
+      it 'should automatically deserialize to a cookie' do
+        json = '{"json_class":"CookieJar::Cookie","name":"foo","value":"bar","domain":"localhost.local","path":"\\/","created_at":"2009-09-11 12:51:03 -0600","expiry":"2009-09-11 19:10:00 -0600","secure":true}'
+        c = JSON.parse json, create_additions: true
+        expect(c).to be_a Cookie
         CookieValidation.validate_cookie 'https://localhost/', c
       end
     end
   rescue LoadError
-    it "does not appear the JSON library is installed" do
-      raise "please install the JSON library"
+    it 'does not appear the JSON library is installed' do
+      raise 'please install the JSON library'
     end
   end
 end