suzuko 0.1.7

data/vendor/bundle/ruby/2.0.0/gems/http-cookie-1.0.2/lib/http/cookie_jar/abstract_saver.rb

@@ -0,0 +1,65 @@
+# :markup: markdown
+
+# An abstract superclass for all saver classes.
+class HTTP::CookieJar::AbstractSaver
+  class << self
+    @@class_map = {}
+
+    # Gets an implementation class by the name, optionally trying to
+    # load "http/cookie_jar/*_saver" if not found.  If loading fails,
+    # IndexError is raised.
+    def implementation(symbol)
+      @@class_map.fetch(symbol)
+    rescue IndexError
+      begin
+        require 'http/cookie_jar/%s_saver' % symbol
+        @@class_map.fetch(symbol)
+      rescue LoadError, IndexError
+        raise IndexError, 'cookie saver unavailable: %s' % symbol.inspect
+      end
+    end
+
+    def inherited(subclass) # :nodoc:
+      @@class_map[class_to_symbol(subclass)] = subclass
+    end
+
+    def class_to_symbol(klass) # :nodoc:
+      klass.name[/[^:]+?(?=Saver$|$)/].downcase.to_sym
+    end
+  end
+
+  # Defines options and their default values.
+  def default_options
+    # {}
+  end
+  private :default_options
+
+  # :call-seq:
+  #   new(**options)
+  #
+  # Called by the constructor of each subclass using super().
+  def initialize(options = nil)
+    options ||= {}
+    @logger  = options[:logger]
+    @session = options[:session]
+    # Initializes each instance variable of the same name as option
+    # keyword.
+    default_options.each_pair { |key, default|
+      instance_variable_set("@#{key}", options.fetch(key, default))
+    }
+  end
+
+  # Implements HTTP::CookieJar#save().
+  #
+  # This is an abstract method that each subclass must override.
+  def save(io, jar)
+    # self
+  end
+
+  # Implements HTTP::CookieJar#load().
+  #
+  # This is an abstract method that each subclass must override.
+  def load(io, jar)
+    # self
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/http-cookie-1.0.2/lib/http/cookie_jar/abstract_store.rb

@@ -0,0 +1,124 @@
+# :markup: markdown
+require 'monitor'
+
+# An abstract superclass for all store classes.
+class HTTP::CookieJar::AbstractStore
+  include MonitorMixin
+
+  class << self
+    @@class_map = {}
+
+    # Gets an implementation class by the name, optionally trying to
+    # load "http/cookie_jar/*_store" if not found.  If loading fails,
+    # IndexError is raised.
+    def implementation(symbol)
+      @@class_map.fetch(symbol)
+    rescue IndexError
+      begin
+        require 'http/cookie_jar/%s_store' % symbol
+        @@class_map.fetch(symbol)
+      rescue LoadError, IndexError
+        raise IndexError, 'cookie store unavailable: %s' % symbol.inspect
+      end
+    end
+
+    def inherited(subclass) # :nodoc:
+      @@class_map[class_to_symbol(subclass)] = subclass
+    end
+
+    def class_to_symbol(klass) # :nodoc:
+      klass.name[/[^:]+?(?=Store$|$)/].downcase.to_sym
+    end
+  end
+
+  # Defines options and their default values.
+  def default_options
+    # {}
+  end
+  private :default_options
+
+  # :call-seq:
+  #   new(**options)
+  #
+  # Called by the constructor of each subclass using super().
+  def initialize(options = nil)
+    super() # MonitorMixin
+    options ||= {}
+    @logger = options[:logger]
+    # Initializes each instance variable of the same name as option
+    # keyword.
+    default_options.each_pair { |key, default|
+      instance_variable_set("@#{key}", options.fetch(key, default))
+    }
+  end
+
+  # This is an abstract method that each subclass must override.
+  def initialize_copy(other)
+    # self
+  end
+
+  # Implements HTTP::CookieJar#add().
+  #
+  # This is an abstract method that each subclass must override.
+  def add(cookie)
+    # self
+  end
+
+  # Implements HTTP::CookieJar#delete().
+  #
+  # This is an abstract method that each subclass must override.
+  def delete(cookie)
+    # self
+  end
+
+  # Iterates over all cookies that are not expired.
+  #
+  # An optional argument +uri+ specifies a URI object indicating the
+  # destination of the cookies being selected.  Every cookie yielded
+  # should be good to send to the given URI,
+  # i.e. cookie.valid_for_uri?(uri) evaluates to true.
+  #
+  # If (and only if) the +uri+ option is given, last access time of
+  # each cookie is updated to the current time.
+  #
+  # This is an abstract method that each subclass must override.
+  def each(uri = nil, &block) # :yield: cookie
+    # if uri
+    #   ...
+    # else
+    #   synchronize {
+    #     ...
+    #   }
+    # end
+    # self
+  end
+  include Enumerable
+
+  # Implements HTTP::CookieJar#empty?().
+  def empty?
+    each { return false }
+    true
+  end
+
+  # Implements HTTP::CookieJar#clear().
+  #
+  # This is an abstract method that each subclass must override.
+  def clear
+    # self
+  end
+
+  # Implements HTTP::CookieJar#cleanup().
+  #
+  # This is an abstract method that each subclass must override.
+  def cleanup(session = false)
+    # if session
+    #   select { |cookie| cookie.session? || cookie.expired? }
+    # else
+    #   select(&:expired?)
+    # end.each { |cookie|
+    #   delete(cookie)
+    # }
+    # # subclasses can optionally remove over-the-limit cookies.
+    # self
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/http-cookie-1.0.2/lib/http/cookie_jar/cookiestxt_saver.rb

@@ -0,0 +1,106 @@
+# :markup: markdown
+require 'http/cookie_jar'
+
+# CookiestxtSaver saves and loads cookies in the cookies.txt format.
+class HTTP::CookieJar::CookiestxtSaver < HTTP::CookieJar::AbstractSaver
+  # :singleton-method: new
+  # :call-seq:
+  #   new(**options)
+  #
+  # Available option keywords are below:
+  #
+  # * `:header`
+  #
+  #     Specifies the header line not including a line feed, which is
+  #     only used by #save().  None is output if nil is
+  #     given. (default: `"# HTTP Cookie File"`)
+  #
+  # * `:linefeed`
+  #
+  #     Specifies the line separator (default: `"\n"`).
+
+  ##
+
+  def save(io, jar)
+    io.puts @header if @header
+    jar.each { |cookie|
+      next if !@session && cookie.session?
+      io.print cookie_to_record(cookie)
+    }
+  end
+
+  def load(io, jar)
+    io.each_line { |line|
+      cookie = parse_record(line) and jar.add(cookie)
+    }
+  end
+
+  private
+
+  def default_options
+    {
+      :header => "# HTTP Cookie File",
+      :linefeed => "\n",
+    }
+  end
+
+  # :stopdoc:
+  True  = "TRUE"
+  False = "FALSE"
+
+  HTTPONLY_PREFIX = '#HttpOnly_'
+  RE_HTTPONLY_PREFIX = /\A#{HTTPONLY_PREFIX}/
+  # :startdoc:
+
+  # Serializes the cookie into a cookies.txt line.
+  def cookie_to_record(cookie)
+    cookie.instance_eval {
+      [
+        @httponly ? HTTPONLY_PREFIX + dot_domain : dot_domain,
+        @for_domain ? True : False,
+        @path,
+        @secure ? True : False,
+        expires.to_i,
+        @name,
+        @value
+      ]
+    }.join("\t") << @linefeed
+  end
+
+  # Parses a line from cookies.txt and returns a cookie object if the
+  # line represents a cookie record or returns nil otherwise.
+  def parse_record(line)
+    case line
+    when RE_HTTPONLY_PREFIX
+      httponly = true
+      line = $'
+    when /\A#/
+      return nil
+    else
+      httponly = false
+    end
+
+    domain,
+    s_for_domain,	# Whether this cookie is for domain
+    path,		# Path for which the cookie is relevant
+    s_secure,		# Requires a secure connection
+    s_expires,		# Time the cookie expires (Unix epoch time)
+    name, value = line.split("\t", 7)
+    return nil if value.nil?
+
+    value.chomp!
+
+    if (expires_seconds = s_expires.to_i).nonzero?
+      expires = Time.at(expires_seconds)
+      return nil if expires < Time.now
+    end
+
+    HTTP::Cookie.new(name, value,
+      :domain => domain,
+      :for_domain => s_for_domain == True,
+      :path => path,
+      :secure => s_secure == True,
+      :httponly => httponly,
+      :expires => expires)
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/http-cookie-1.0.2/lib/http/cookie_jar/hash_store.rb

@@ -0,0 +1,163 @@
+# :markup: markdown
+require 'http/cookie_jar'
+
+class HTTP::CookieJar
+  # A store class that uses a hash-based cookie store.
+  #
+  # In this store, cookies that share the same name, domain and path
+  # will overwrite each other regardless of the `for_domain` flag
+  # value.  This store is built after the storage model described in
+  # RFC 6265 5.3 where there is no mention of how the host-only-flag
+  # affects in storing cookies.  On the other hand, in MozillaStore
+  # two cookies with the same name, domain and path coexist as long as
+  # they differ in the `for_domain` flag value, which means they need
+  # to be expired individually.
+  class HashStore < AbstractStore
+    def default_options
+      {
+        :gc_threshold => HTTP::Cookie::MAX_COOKIES_TOTAL / 20
+      }
+    end
+
+    # :call-seq:
+    #   new(**options)
+    #
+    # Generates a hash based cookie store.
+    #
+    # Available option keywords are as below:
+    #
+    # :gc_threshold
+    # : GC threshold; A GC happens when this many times cookies have
+    # been stored (default: `HTTP::Cookie::MAX_COOKIES_TOTAL / 20`)
+    def initialize(options = nil)
+      super
+
+      @jar = {
+      # hostname => {
+      #   path => {
+      #     name => cookie,
+      #     ...
+      #   },
+      #   ...
+      # },
+      # ...
+      }
+
+      @gc_index = 0
+    end
+
+    # The copy constructor.  This store class supports cloning.
+    def initialize_copy(other)
+      @jar = Marshal.load(Marshal.dump(other.instance_variable_get(:@jar)))
+    end
+
+    def add(cookie)
+      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] ||= {})[cookie.path] ||= {})
+      path_cookies.delete(cookie.name)
+      self
+    end
+
+    def each(uri = nil) # :yield: cookie
+      now = Time.now
+      if uri
+        thost = DomainName.new(uri.host)
+        tpath = uri.path
+        @jar.each { |domain, paths|
+          next unless thost.cookie_domain?(domain)
+          paths.each { |path, hash|
+            next unless HTTP::Cookie.path_match?(path, tpath)
+            hash.delete_if { |name, cookie|
+              if cookie.expired?(now)
+                true
+              else
+                if cookie.valid_for_uri?(uri)
+                  cookie.accessed_at = now
+                  yield cookie
+                end
+                false
+              end
+            }
+          }
+        }
+      else
+        synchronize {
+          @jar.each { |domain, paths|
+            paths.each { |path, hash|
+              hash.delete_if { |name, cookie|
+                if cookie.expired?(now)
+                  true
+                else
+                  yield cookie
+                  false
+                end
+              }
+            }
+          }
+        }
+      end
+      self
+    end
+
+    def clear
+      @jar.clear
+      self
+    end
+
+    def cleanup(session = false)
+      now = Time.now
+      all_cookies = []
+
+      synchronize {
+        break if @gc_index == 0
+
+        @jar.each { |domain, paths|
+          domain_cookies = []
+
+          paths.each { |path, hash|
+            hash.delete_if { |name, cookie|
+              if cookie.expired?(now) || (session && cookie.session?)
+                true
+              else
+                domain_cookies << cookie
+                false
+              end
+            }
+          }
+
+          if (debt = domain_cookies.size - HTTP::Cookie::MAX_COOKIES_PER_DOMAIN) > 0
+            domain_cookies.sort_by!(&:created_at)
+            domain_cookies.slice!(0, debt).each { |cookie|
+              delete(cookie)
+            }
+          end
+
+          all_cookies.concat(domain_cookies)
+        }
+
+        if (debt = all_cookies.size - HTTP::Cookie::MAX_COOKIES_TOTAL) > 0
+          all_cookies.sort_by!(&:created_at)
+          all_cookies.slice!(0, debt).each { |cookie|
+            delete(cookie)
+          }
+        end
+
+        @jar.delete_if { |domain, paths|
+          paths.delete_if { |path, hash|
+            hash.empty?
+          }
+          paths.empty?
+        }
+
+        @gc_index = 0
+      }
+      self
+    end
+  end
+end