husc 0.1.0

data/vendor/bundle/gems/mechanize-2.7.6/lib/mechanize/chunked_termination_error.rb

@@ -0,0 +1,7 @@
+##
+# Raised when Mechanize detects the chunked transfer-encoding may be
+# incorrectly terminated.
+
+class Mechanize::ChunkedTerminationError < Mechanize::ResponseReadError
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/lib/mechanize/content_type_error.rb

@@ -0,0 +1,13 @@
+##
+# This error is raised when a pluggable parser tries to parse a content type
+# that it does not know how to handle.  For example if Mechanize::Page were to
+# try to parse a PDF, a ContentTypeError would be thrown.
+
+class Mechanize::ContentTypeError < Mechanize::Error
+  attr_reader :content_type
+
+  def initialize(content_type)
+    @content_type = content_type
+  end
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/lib/mechanize/cookie.rb

@@ -0,0 +1,73 @@
+warn 'mechanize/cookie will be deprecated.  Please migrate to the http-cookie APIs.' if $VERBOSE
+
+require 'http/cookie'
+
+class Mechanize
+  module CookieDeprecated
+    def __deprecated__(to = nil)
+      $VERBOSE or return
+      method = caller[0][/([^`]+)(?='$)/]
+      to ||= method
+      case self
+      when Class
+        lname = name[/[^:]+$/]
+        klass = 'Mechanize::%s' % lname
+        this = '%s.%s' % [klass, method]
+        that = 'HTTP::%s.%s' % [lname, to]
+      else
+        lname = self.class.name[/[^:]+$/]
+        klass = 'Mechanize::%s' % lname
+        this = '%s#%s' % [klass, method]
+        that = 'HTTP::%s#%s' % [lname, to]
+      end
+      warn '%s: The call of %s needs to be fixed to follow the new API (%s).' % [caller[1], this, that]
+    end
+    private :__deprecated__
+  end
+
+  module CookieCMethods
+    include CookieDeprecated
+
+    def parse(arg1, arg2, arg3 = nil, &block)
+      if arg1.is_a?(URI)
+        __deprecated__
+        return [] if arg2.nil?
+        super(arg2, arg1, { :logger => arg3 })
+      else
+        super
+      end
+    end
+  end
+
+  module CookieIMethods
+    include CookieDeprecated
+
+    def set_domain(domain)
+      __deprecated__ :domain=
+      @domain = domain
+    end
+  end
+
+  Cookie = ::HTTP::Cookie
+
+  # Compatibility for Ruby 1.8/1.9
+  unless Cookie.respond_to?(:prepend, true)
+    require 'mechanize/prependable'
+
+    class Cookie
+      extend Prependable
+
+      class << self
+        extend Prependable
+      end
+    end
+  end
+
+  class Cookie
+    prepend CookieIMethods
+
+    class << self
+      prepend CookieCMethods
+    end
+  end
+end

data/vendor/bundle/gems/mechanize-2.7.6/lib/mechanize/cookie_jar.rb

@@ -0,0 +1,190 @@
+warn 'mechanize/cookie_jar will be deprecated.  Please migrate to the http-cookie APIs.' if $VERBOSE
+
+require 'http/cookie_jar'
+require 'http/cookie_jar/yaml_saver'
+require 'mechanize/cookie'
+
+class Mechanize
+  module CookieJarIMethods
+    include CookieDeprecated
+
+    def add(arg1, arg2 = nil)
+      if arg2
+        __deprecated__ 'add and origin='
+        super arg2.dup.tap { |ncookie|
+          begin
+            ncookie.origin = arg1
+          rescue
+            return nil
+          end
+        }
+      else
+        super arg1
+      end
+    end
+
+    # See HTTP::CookieJar#add.
+    def add!(cookie)
+      __deprecated__ :add
+      cookie.domain.nil? and raise NoMethodError, 'raised for compatibility'
+      @store.add(cookie)
+      self
+    end
+
+    # See HTTP::CookieJar#save.
+    def save_as(filename, *options)
+      __deprecated__ :save
+      save(filename, *options)
+    end
+
+    # See HTTP::CookieJar#clear.
+    def clear!
+      __deprecated__ :clear
+      clear
+    end
+
+    # See HTTP::CookieJar#store.
+    def jar
+      __deprecated__ :store
+      @store.instance_variable_get(:@jar)
+    end
+
+    # See HTTP::CookieJar#load.
+    def load_cookiestxt(io)
+      __deprecated__ :load
+      load(io, :cookiestxt)
+    end
+
+    # See HTTP::CookieJar#save.
+    def dump_cookiestxt(io)
+      __deprecated__ :save
+      save(io, :cookiestxt)
+    end
+  end
+
+  class CookieJar < ::HTTP::CookieJar
+    def save(output, *options)
+      output.respond_to?(:write) or
+        return open(output, 'w') { |io| save(io, *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
+
+      return super(output, opthash) if opthash[:format] != :yaml
+
+      session = opthash[:session]
+      nstore = HashStore.new
+
+      each { |cookie|
+        next if !session && cookie.session?
+
+        if cookie.max_age
+          cookie = cookie.dup
+          cookie.expires = cookie.expires # convert max_age to expires
+        end
+        nstore.add(cookie)
+      }
+
+      yaml = YAML.dump(nstore.instance_variable_get(:@jar))
+
+      # a gross hack
+      yaml.gsub!(%r{^(    [^ ].*: !ruby/object:)HTTP::Cookie$}) {
+        $1 + 'Mechanize::Cookie'
+      }
+      yaml.gsub!(%r{^(      expires: )(?:|!!null|(.+?)) *$}) {
+        $1 + ($2 ? Time.parse($2).httpdate : '')
+      }
+
+      output.write yaml
+
+      self
+    end
+
+    def load(input, *options)
+      input.respond_to?(:write) or
+        return open(input, 'r') { |io| load(io, *options) }
+
+      opthash = {
+        :format => :yaml,
+        :session => false,
+      }
+      case options.size
+      when 0
+      when 1
+        case options = options.first
+        when Symbol
+          opthash[:format] = options
+        else
+          if hash = Hash.try_convert(options)
+            opthash.update(hash)
+          end
+        end
+      when 2
+        opthash[:format], options = options
+        if hash = Hash.try_convert(options)
+          opthash.update(hash)
+        end
+      else
+        raise ArgumentError, 'wrong number of arguments (%d for 1-3)' % (1 + options.size)
+      end
+
+      return super(input, opthash) if opthash[:format] != :yaml
+
+      begin
+        data = YAML.load(input)
+      rescue ArgumentError
+        @logger.warn "unloadable YAML cookie data discarded" if @logger
+        return self
+      end
+
+      case data
+      when Array
+        # Forward compatibility
+        data.each { |cookie|
+          add(cookie)
+        }
+      when Hash
+        data.each { |domain, paths|
+          paths.each { |path, names|
+            names.each { |cookie_name, cookie|
+              add(cookie)
+            }
+          }
+        }
+      else
+        @logger.warn "incompatible YAML cookie data discarded" if @logger
+        return self
+      end
+    end
+  end
+
+  # Compatibility for Ruby 1.8/1.9
+  unless ::HTTP::CookieJar.respond_to?(:prepend, true)
+    require 'mechanize/prependable'
+
+    class ::HTTP::CookieJar
+      extend Prependable
+    end
+  end
+
+  class ::HTTP::CookieJar
+    prepend CookieJarIMethods
+  end
+end

data/vendor/bundle/gems/mechanize-2.7.6/lib/mechanize/directory_saver.rb

@@ -0,0 +1,77 @@
+##
+# Unlike Mechanize::FileSaver, the directory saver places all downloaded files
+# in a single pre-specified directory.
+#
+# You must register the directory to save to before using the directory saver:
+#
+#   agent.pluggable_parser['image'] = \
+#     Mechanize::DirectorySaver.save_to 'images'
+
+class Mechanize::DirectorySaver < Mechanize::Download
+
+  @directory = nil
+  @options = {}
+
+  ##
+  # Creates a DirectorySaver subclass that will save responses to the given
+  # +directory+. If +options+ includes a +decode_filename+ value set to +true+
+  # then the downloaded filename will be ran through +CGI.unescape+ before
+  # being saved. If +options+ includes a +overwrite+ value set to +true+ then
+  # downloaded file will be overwritten if two files with the same names exist.
+
+  def self.save_to directory, options = {}
+    directory = File.expand_path directory
+
+    Class.new self do |klass|
+      klass.instance_variable_set :@directory, directory
+      klass.instance_variable_set :@options, options
+    end
+  end
+
+  ##
+  # The directory downloaded files will be saved to.
+
+  def self.directory
+    @directory
+  end
+
+  ##
+  # True if downloaded files should have their names decoded before saving.
+
+  def self.decode_filename?
+    @options[:decode_filename]
+  end
+
+  ##
+  # Checks if +overwrite+ parameter is set to true
+
+  def self.overwrite?
+    @options[:overwrite]
+  end
+
+  ##
+  # Saves the +body_io+ into the directory specified for this DirectorySaver
+  # by save_to.  The filename is chosen by Mechanize::Parser#extract_filename.
+
+  def initialize uri = nil, response = nil, body_io = nil, code = nil
+    directory = self.class.directory
+
+    raise Mechanize::Error,
+      'no save directory specified - ' \
+      'use Mechanize::DirectorySaver.save_to ' \
+      'and register the resulting class' unless directory
+
+    super
+
+    @filename = CGI.unescape(@filename) if self.class.decode_filename?
+    path = File.join directory, @filename
+
+    if self.class.overwrite?
+      save! path
+    else
+      save path
+    end
+  end
+
+end
+

data/vendor/bundle/gems/mechanize-2.7.6/lib/mechanize/download.rb

@@ -0,0 +1,84 @@
+##
+# Download is a pluggable parser for downloading files without loading them
+# into memory first.  You may subclass this class to handle content types you
+# do not wish to load into memory first.
+#
+# See Mechanize::PluggableParser for instructions on using this class.
+
+class Mechanize::Download
+
+  include Mechanize::Parser
+
+  ##
+  # The filename for this file based on the content-disposition of the
+  # response or the basename of the URL
+
+  attr_accessor :filename
+
+  ##
+  # Accessor for the IO-like that contains the body
+
+  attr_reader :body_io
+
+  alias content body_io
+
+  ##
+  # Creates a new download retrieved from the given +uri+ and +response+
+  # object.  The +body_io+ is an IO-like containing the HTTP response body and
+  # +code+ is the HTTP status.
+
+  def initialize uri = nil, response = nil, body_io = nil, code = nil
+    @uri      = uri
+    @body_io  = body_io
+    @code     = code
+
+    @full_path = false unless defined? @full_path
+
+    fill_header response
+    extract_filename
+
+    yield self if block_given?
+  end
+
+  ##
+  # The body of this response as a String.
+  #
+  # Take care, this may use lots of memory if the response body is large.
+
+  def body
+    @body_io.read.tap { @body_io.rewind }
+  end
+
+  ##
+  # Saves a copy of the body_io to +filename+
+  # returns the filename
+
+  def save filename = nil
+    filename = find_free_name filename
+    save! filename
+  end
+
+  alias save_as save
+
+  ##
+  # Use this method to save the content of body_io to +filename+.
+  # This method will overwrite any existing filename that exists with the
+  # same name.
+  # returns the filename
+
+  def save! filename = nil
+    filename ||= @filename
+    dirname = File.dirname filename
+    FileUtils.mkdir_p dirname
+
+    open filename, 'wb' do |io|
+      until @body_io.eof? do
+        io.write @body_io.read 16384
+      end
+    end
+
+    filename
+  end
+
+end
+