http-cookie 0.1.0

data/lib/http/cookie/version.rb

@@ -0,0 +1,5 @@
+module HTTP
+  class Cookie
+    VERSION = "0.1.0"
+  end
+end

data/lib/http/cookie_jar.rb

@@ -0,0 +1,233 @@
+require 'http/cookie'
+
+##
+# This class is used to manage the Cookies that have been returned from
+# any particular website.
+
+class HTTP::CookieJar
+  autoload :AbstractSaver, 'http/cookie_jar/abstract_saver'
+  autoload :AbstractStore, 'http/cookie_jar/abstract_store'
+
+  attr_reader :store
+
+  def initialize(store = :hash, options = nil)
+    case store
+    when Symbol
+      @store = AbstractStore.implementation(store).new(options)
+    when AbstractStore
+      options.empty? or
+        raise ArgumentError, 'wrong number of arguments (%d for 1)' % (1 + options.size)
+      @store = store
+    else
+      raise TypeError, 'wrong object given as cookie store: %s' % store.inspect
+    end
+  end
+
+  def initialize_copy(other)
+    @store = other.instance_eval { @store.dup }
+  end
+
+  # Add a +cookie+ to the jar and return self.
+  def add(cookie, *_)
+    _.empty? or
+      raise ArgumentError, 'HTTP::Cookie equivalent for Mechanize::CookieJar#add(uri, cookie) is #add(cookie) after setting cookie.origin = uri.'
+
+    if cookie.domain.nil? || cookie.path.nil?
+      raise ArgumentError, "a cookie with unknown domain or path cannot be added"
+    end
+
+    @store.add(cookie)
+    self
+  end
+  alias << add
+
+  # Used to exist in Mechanize::CookieJar.  Use #add().
+  def add!(cookie)
+    raise NoMethodError, 'HTTP::Cookie equivalent for Mechanize::CookieJar#add!() is #add().'
+  end
+
+  # Fetch the cookies that should be used for the URL/URI.
+  def cookies(url)
+    now = Time.now
+    each(url).select { |cookie|
+      !cookie.expired? && (cookie.accessed_at = now)
+    }.sort
+  end
+
+  # Tests if the jar is empty.  If url is given, tests if there is no
+  # cookie for the URL.
+  def empty?(url = nil)
+    if url
+      each(url) { return false }
+      return true
+    else
+      @store.empty?
+    end
+  end
+
+  # Iterates over all cookies that are not expired.
+  #
+  # Available option keywords are below:
+  #
+  # * +uri+
+  #
+  #   Specify a URI/URL 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) this option is given, last access time of each
+  #   cookie is updated to the current time.
+  def each(uri = nil, &block)
+    block_given? or return enum_for(__method__, uri)
+
+    if uri
+      block = proc { |cookie|
+        yield cookie if cookie.valid_for_uri?(uri)
+      }
+    end
+
+    @store.each(uri, &block)
+    self
+  end
+  include Enumerable
+
+  # call-seq:
+  #   jar.save(filename_or_io, **options)
+  #   jar.save(filename_or_io, format = :yaml, **options)
+  #
+  # Save the cookie jar into a file or an IO in the format specified
+  # and return self.  If the given object responds to #write it is
+  # taken as an IO, or taken as a filename otherwise.
+  #
+  # Available option keywords are below:
+  #
+  # * +format+
+  #   [<tt>:yaml</tt>]
+  #     YAML structure (default)
+  #   [<tt>:cookiestxt</tt>]
+  #     Mozilla's cookies.txt format
+  # * +session+
+  #   [+true+]
+  #     Save session cookies as well.
+  #   [+false+]
+  #     Do not save session cookies. (default)
+  #
+  # All options given are passed through to the underlying cookie
+  # saver module.
+  def save(writable, *options)
+    opthash = {
+      :format => :yaml,
+      :session => false,
+    }
+    case options.size
+    when 0
+    when 1
+      case options = options.first
+      when Symbol
+        opthash[:format] = options
+      else
+        opthash.update(options) if options
+      end
+    when 2
+      opthash[:format], options = options
+      opthash.update(options) if options
+    else
+      raise ArgumentError, 'wrong number of arguments (%d for 1-3)' % (1 + options.size)
+    end
+
+    begin
+      saver = AbstractSaver.implementation(opthash[:format]).new(opthash)
+    rescue KeyError => e
+      raise ArgumentError, e.message
+    end
+
+    if writable.respond_to?(:write)
+      saver.save(writable, self)
+    else
+      File.open(writable, 'w') { |io|
+        saver.save(io, self)
+      }
+    end
+
+    self
+  end
+
+  # Used to exist in Mechanize::CookieJar.  Use #save().
+  def save_as(*args)
+    raise NoMethodError, 'HTTP::Cookie equivalent for Mechanize::CookieJar#save_as() is #save().'
+  end
+
+  # call-seq:
+  #   jar.load(filename_or_io, **options)
+  #   jar.load(filename_or_io, format = :yaml, **options)
+  #
+  # Load cookies recorded in a file or an IO in the format specified
+  # into the jar and return self.  If the given object responds to
+  # #read it is taken as an IO, or taken as a filename otherwise.
+  #
+  # Available option keywords are below:
+  #
+  # * +format+
+  #   [<tt>:yaml</tt>]
+  #     YAML structure (default)
+  #   [<tt>:cookiestxt</tt>]
+  #     Mozilla's cookies.txt format
+  #
+  # All options given are passed through to the underlying cookie
+  # saver module.
+  def load(readable, *options)
+    opthash = {
+      :format => :yaml,
+      :session => false,
+    }
+    case options.size
+    when 0
+    when 1
+      case options = options.first
+      when Symbol
+        opthash[:format] = options
+      else
+        opthash.update(options) if options
+      end
+    when 2
+      opthash[:format], options = options
+      opthash.update(options) if options
+    else
+      raise ArgumentError, 'wrong number of arguments (%d for 1-3)' % (1 + options.size)
+    end
+
+    begin
+      saver = AbstractSaver.implementation(opthash[:format]).new(opthash)
+    rescue KeyError => e
+      raise ArgumentError, e.message
+    end
+
+    if readable.respond_to?(:write)
+      saver.load(readable, self)
+    else
+      File.open(readable, 'r') { |io|
+        saver.load(io, self)
+      }
+    end
+
+    self
+  end
+
+  # Clear the cookie jar and return self.
+  def clear
+    @store.clear
+    self
+  end
+
+  # Used to exist in Mechanize::CookieJar.  Use #clear().
+  def clear!(*args)
+    raise NoMethodError, 'HTTP::Cookie equivalent for Mechanize::CookieJar#clear!() is #clear().'
+  end
+
+  # Remove expired cookies and return self.
+  def cleanup(session = false)
+    @store.cleanup session
+    self
+  end
+end

data/lib/http/cookie_jar/abstract_saver.rb

@@ -0,0 +1,53 @@
+require 'http/cookie_jar'
+
+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,
+    # KeyError is raised.
+    def implementation(symbol)
+      @@class_map.fetch(symbol)
+    rescue KeyError
+      begin
+        require 'http/cookie_jar/%s_saver' % symbol
+        @@class_map.fetch(symbol)
+      rescue LoadError, KeyError => e
+        raise KeyError, 'cookie saver unavailable: %s' % symbol.inspect
+      end
+    end
+
+    def inherited(subclass)
+      @@class_map[class_to_symbol(subclass)] = subclass
+    end
+
+    def class_to_symbol(klass)
+      klass.name[/[^:]+?(?=Saver$|$)/].downcase.to_sym
+    end
+  end
+
+  def default_options
+    {}
+  end
+  private :default_options
+
+  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.key?(key) ? options[key] : default)
+    }
+  end
+
+  def save(io, jar)
+    raise
+  end
+
+  def load(io, jar)
+    raise
+  end
+end

data/lib/http/cookie_jar/abstract_store.rb

@@ -0,0 +1,90 @@
+require 'http/cookie_jar'
+
+class HTTP::CookieJar::AbstractStore
+  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,
+    # KeyError is raised.
+    def implementation(symbol)
+      @@class_map.fetch(symbol)
+    rescue KeyError
+      begin
+        require 'http/cookie_jar/%s_store' % symbol
+        @@class_map.fetch(symbol)
+      rescue LoadError, KeyError => e
+        raise KeyError, 'cookie store unavailable: %s' % symbol.inspect
+      end
+    end
+
+    def inherited(subclass)
+      @@class_map[class_to_symbol(subclass)] = subclass
+    end
+
+    def class_to_symbol(klass)
+      klass.name[/[^:]+?(?=Store$|$)/].downcase.to_sym
+    end
+  end
+
+  def default_options
+    {}
+  end
+  private :default_options
+
+  def initialize(options = nil)
+    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.key?(key) ? options[key] : default)
+    }
+  end
+
+  def initialize_copy(other)
+    raise
+    self
+  end
+
+  def add(cookie)
+    raise
+    self
+  end
+
+  # Iterates over all cookies that are not expired.
+  #
+  # Available option keywords are below:
+  #
+  # * +uri+
+  #
+  #   Specify 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) this option is given, last access time of each
+  #   cookie is updated to the current time.
+  def each(options = nil, &block)
+    raise
+    self
+  end
+  include Enumerable
+
+  def clear
+    raise
+    self
+  end
+
+  def cleanup(session = false)
+    if session
+      select { |cookie| cookie.session? || cookie.expired? }
+    else
+      select(&:expired?)
+    end.each { |cookie|
+      add(cookie.expire)
+    }
+    # subclasses can optionally remove over-the-limit cookies.
+    self
+  end
+end

data/lib/http/cookie_jar/cookiestxt_saver.rb

@@ -0,0 +1,74 @@
+require 'http/cookie_jar'
+
+# CookiestxtSaver saves and loads cookies in the cookies.txt format.
+class HTTP::CookieJar::CookiestxtSaver < HTTP::CookieJar::AbstractSaver
+  True  = "TRUE"
+  False = "FALSE"
+
+  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
+
+  # Serializes the cookie into a cookies.txt line.
+  def cookie_to_record(cookie)
+    cookie.instance_eval {
+      [
+        @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)
+    return nil if line.match(/^#/)
+
+    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,
+      :expires => expires,
+      :version => 0)
+  end
+end