husc 0.1.0

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

@@ -0,0 +1,179 @@
+require 'mechanize/file'
+require 'mechanize/file_saver'
+require 'mechanize/page'
+require 'mechanize/xml_file'
+require 'mime/types'
+
+##
+# Mechanize allows different parsers for different content types.  Mechanize
+# uses PluggableParser to determine which parser to use for any content type.
+# To use your own parser or to change the default parsers, register them with
+# this class through Mechanize#pluggable_parser.
+#
+# The default parser for unregistered content types is Mechanize::File.
+#
+# The module Mechanize::Parser provides basic functionality for any content
+# type, so you may use it in custom parsers you write.  For small files you
+# wish to perform in-memory operations on, you should subclass
+# Mechanize::File.  For large files you should subclass Mechanize::Download as
+# the content is only loaded into memory in small chunks.
+#
+# When writing your own pluggable parser, be sure to provide a method #body
+# that returns a String containing the response body for compatibility with
+# Mechanize#get_file.
+#
+# == Example
+#
+# To create your own parser, just create a class that takes four parameters in
+# the constructor.  Here is an example of registering a parser that handles
+# CSV files:
+#
+#   require 'csv'
+#
+#   class CSVParser < Mechanize::File
+#     attr_reader :csv
+#
+#     def initialize uri = nil, response = nil, body = nil, code = nil
+#       super uri, response, body, code
+#       @csv = CSV.parse body
+#     end
+#   end
+#
+#   agent = Mechanize.new
+#   agent.pluggable_parser.csv = CSVParser
+#   agent.get('http://example.com/test.csv')  # => CSVParser
+#
+# Now any response with a content type of 'text/csv' will initialize a
+# CSVParser and return that object to the caller.
+#
+# To register a parser for a content type that Mechanize does not know about,
+# use the hash syntax:
+#
+#   agent.pluggable_parser['text/something'] = SomeClass
+#
+# To set the default parser, use #default:
+#
+#   agent.pluggable_parser.default = Mechanize::Download
+#
+# Now all unknown content types will be saved to disk and not loaded into
+# memory.
+
+class Mechanize::PluggableParser
+
+  CONTENT_TYPES = {
+    :html  => 'text/html',
+    :wap   => 'application/vnd.wap.xhtml+xml',
+    :xhtml => 'application/xhtml+xml',
+    :pdf   => 'application/pdf',
+    :csv   => 'text/csv',
+    :xml   => ['text/xml', 'application/xml'],
+  }
+
+  InvalidContentTypeError =
+    if defined?(MIME::Type::InvalidContentType)
+      # For mime-types >=2.1
+      MIME::Type::InvalidContentType
+    else
+      # For mime-types <2.1
+      MIME::InvalidContentType
+    end
+
+  attr_accessor :default
+
+  def initialize
+    @parsers = {
+      CONTENT_TYPES[:html]  => Mechanize::Page,
+      CONTENT_TYPES[:xhtml] => Mechanize::Page,
+      CONTENT_TYPES[:wap]   => Mechanize::Page,
+      'image'               => Mechanize::Image,
+      'text/xml'            => Mechanize::XmlFile,
+      'application/xml'     => Mechanize::XmlFile,
+    }
+
+    @default = Mechanize::File
+  end
+
+  ##
+  # Returns the parser registered for the given +content_type+
+
+  def parser content_type
+    return default unless content_type
+
+    parser = @parsers[content_type]
+
+    return parser if parser
+
+    mime_type = MIME::Type.new content_type
+
+    parser = @parsers[mime_type.to_s] ||
+             @parsers[mime_type.simplified] ||
+             # Starting from mime-types 3.0 x-prefix is deprecated as per IANA
+             (@parsers[MIME::Type.simplified(mime_type.to_s, remove_x_prefix: true)] rescue nil) ||
+             @parsers[mime_type.media_type] ||
+             default
+  rescue InvalidContentTypeError
+    default
+  end
+
+  def register_parser content_type, klass # :nodoc:
+    @parsers[content_type] = klass
+  end
+
+  ##
+  # Registers +klass+ as the parser for text/html and application/xhtml+xml
+  # content
+
+  def html=(klass)
+    register_parser(CONTENT_TYPES[:html], klass)
+    register_parser(CONTENT_TYPES[:xhtml], klass)
+  end
+
+  ##
+  # Registers +klass+ as the parser for application/xhtml+xml content
+
+  def xhtml=(klass)
+    register_parser(CONTENT_TYPES[:xhtml], klass)
+  end
+
+  ##
+  # Registers +klass+ as the parser for application/pdf content
+
+  def pdf=(klass)
+    register_parser(CONTENT_TYPES[:pdf], klass)
+  end
+
+  ##
+  # Registers +klass+ as the parser for text/csv content
+
+  def csv=(klass)
+    register_parser(CONTENT_TYPES[:csv], klass)
+  end
+
+  ##
+  # Registers +klass+ as the parser for text/xml content
+
+  def xml=(klass)
+    CONTENT_TYPES[:xml].each do |content_type|
+      register_parser content_type, klass
+    end
+  end
+
+  ##
+  # Retrieves the parser for +content_type+ content
+
+  def [](content_type)
+    @parsers[content_type]
+  end
+
+  ##
+  # Sets the parser for +content_type+ content to +klass+
+  #
+  # The +content_type+ may either be a full MIME type a simplified MIME type
+  # ('text/x-csv' simplifies to 'text/csv') or a media type like 'image'.
+
+  def []= content_type, klass
+    register_parser content_type, klass
+  end
+
+end
+

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

@@ -0,0 +1,89 @@
+# Fake implementation of prepend(), which does not support overriding
+# inherited methods nor methods that are formerly overridden by
+# another invocation of prepend().
+#
+# Here's what <Original>.prepend(<Wrapper>) does:
+#
+# - Create an anonymous stub module (hereinafter <Stub>) and define
+#   <Stub>#<method> that calls #<method>_without_<Wrapper> for each
+#   instance method of <Wrapper>.
+#
+# - Rename <Original>#<method> to #<method>_without_<Wrapper> for each
+#   instance method of <Wrapper>.
+#
+# - Include <Wrapper> and <Stub> into <Original> in that order.
+#
+# This way, a call of <Original>#<method> is dispatched to
+# <Wrapper><method>, which may call super which is dispatched to
+# <Stub>#<method>, which finally calls
+# <Original>#<method>_without_<Wrapper> which is used to be called
+# <Original>#<method>.
+#
+# Usage:
+#
+#     class Mechanize
+#       # module with methods that overrides those of X
+#       module Y
+#       end
+#
+#       unless X.respond_to?(:prepend, true)
+#         require 'mechanize/prependable'
+#         X.extend(Prependable)
+#       end
+#
+#       class X
+#         prepend Y
+#       end
+#     end
+module Mechanize::Prependable
+  def prepend(mod)
+    stub = Module.new
+
+    mod_id = (mod.name || 'Module__%d' % mod.object_id).gsub(/::/, '__')
+
+    mod.instance_methods.each { |name|
+      method_defined?(name) or next
+
+      original = instance_method(name)
+      if original.owner != self
+        warn "%s cannot override an inherited method: %s(%s)#%s" % [
+          __method__, self, original.owner, name
+        ]
+        next
+      end
+
+      name = name.to_s
+      name_without = name.sub(/(?=[?!=]?\z)/) { '_without_%s' % mod_id }
+
+      arity = original.arity
+      arglist = (
+        if arity >= 0
+          (1..arity).map { |i| 'x%d' % i }
+        else
+          (1..(-arity - 1)).map { |i| 'x%d' % i } << '*a'
+        end << '&b'
+      ).join(', ')
+
+      if name.end_with?('=')
+        stub.module_eval %{
+          def #{name}(#{arglist})
+            __send__(:#{name_without}, #{arglist})
+          end
+        }
+      else
+        stub.module_eval %{
+          def #{name}(#{arglist})
+            #{name_without}(#{arglist})
+          end
+        }
+      end
+      module_eval {
+        alias_method name_without, name
+        remove_method name
+      }
+    }
+
+    include(mod, stub)
+  end
+  private :prepend
+end

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

@@ -0,0 +1,19 @@
+##
+# Raised when too many redirects are sent
+
+class Mechanize::RedirectLimitReachedError < Mechanize::Error
+
+  attr_reader :page
+  attr_reader :redirects
+  attr_reader :response_code
+
+  def initialize page, redirects
+    @page          = page
+    @redirects     = redirects
+    @response_code = page.code
+
+    super "Redirect limit of #{redirects} reached"
+  end
+
+end
+

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

@@ -0,0 +1,21 @@
+##
+# Raised when a POST, PUT, or DELETE request results in a redirect
+# see RFC 2616 10.3.2, 10.3.3 http://www.ietf.org/rfc/rfc2616.txt
+
+class Mechanize::RedirectNotGetOrHeadError < Mechanize::Error
+  attr_reader :page, :response_code, :verb, :uri
+  def initialize(page, verb)
+    @page           = page
+    @verb           = verb
+    @uri            = page.uri
+    @response_code  = page.code
+  end
+
+  def to_s
+    method = @verb.to_s.upcase
+    "#{@response_code} redirect received after a #{method} request"
+  end
+
+  alias :inspect :to_s
+end
+

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

@@ -0,0 +1,26 @@
+# This error is raised when Mechanize encounters a response code it does not
+# know how to handle.  Currently, this exception will be thrown if Mechanize
+# encounters response codes other than 200, 301, or 302.  Any other response
+# code is up to the user to handle.
+
+class Mechanize::ResponseCodeError < Mechanize::Error
+  attr_reader :response_code
+  attr_reader :page
+
+  def initialize(page, message = nil)
+    super message
+
+    @page          = page
+    @response_code = page.code.to_s
+  end
+
+  def to_s
+    response_class = Net::HTTPResponse::CODE_TO_OBJ[@response_code]
+    out = "#{@response_code} => #{response_class} "
+    out << "for #{@page.uri} " if @page.respond_to? :uri # may be HTTPResponse
+    out << "-- #{super}"
+  end
+
+  alias inspect to_s
+end
+

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

@@ -0,0 +1,38 @@
+##
+# Raised when Mechanize encounters an error while reading the response body
+# from the server.  Contains the response headers and the response body up to
+# the error along with the initial error.
+
+class Mechanize::ResponseReadError < Mechanize::Error
+
+  attr_reader :body_io
+  attr_reader :error
+  attr_reader :mechanize
+  attr_reader :response
+  attr_reader :uri
+
+  ##
+  # Creates a new ResponseReadError with the +error+ raised, the +response+
+  # and the +body_io+ for content read so far.
+
+  def initialize error, response, body_io, uri, mechanize
+    @body_io   = body_io
+    @error     = error
+    @mechanize = mechanize
+    @response  = response
+    @uri       = uri
+  end
+
+  ##
+  # Converts this error into a Page, File, etc. based on the content-type
+
+  def force_parse
+    @mechanize.parse @uri, @response, @body_io
+  end
+
+  def message # :nodoc:
+    "#{@error.message} (#{self.class})"
+  end
+
+end
+

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

@@ -0,0 +1,28 @@
+# Exception that is raised when an access to a resource is disallowed by
+# robots.txt or by HTML document itself.
+
+class Mechanize::RobotsDisallowedError < Mechanize::Error
+  def initialize(url)
+    if url.is_a?(URI)
+      @url = url.to_s
+      @uri = url
+    else
+      @url = url.to_s
+    end
+  end
+
+  # Returns the URL (string) of the resource that caused this error.
+  attr_reader :url
+
+  # Returns the URL (URI object) of the resource that caused this
+  # error.  URI::InvalidURIError may be raised if the URL happens to
+  # be invalid or not understood by the URI library.
+  def uri
+    @uri ||= URI.parse(url)
+  end
+
+  def to_s
+    "Robots access is disallowed for URL: #{url}"
+  end
+  alias :inspect :to_s
+end

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

@@ -0,0 +1,330 @@
+require 'mechanize'
+require 'logger'
+require 'tempfile'
+require 'tmpdir'
+require 'webrick'
+require 'zlib'
+
+require 'rubygems'
+
+begin
+  gem 'minitest'
+rescue Gem::LoadError
+end
+
+require 'minitest/autorun'
+
+begin
+  require 'minitest/pride'
+rescue LoadError
+end
+
+##
+# A generic test case for testing mechanize.  Using a subclass of
+# Mechanize::TestCase for your tests will create an isolated mechanize
+# instance that won't pollute your filesystem or other tests.
+#
+# Once Mechanize::TestCase is loaded no HTTP requests will be made outside
+# mechanize itself.  All requests are handled via WEBrick servlets.
+#
+# Mechanize uses WEBrick servlets to test some functionality.  You can run
+# other HTTP clients against the servlets using:
+#
+#   ruby -rmechanize/test_case/server -e0
+#
+# Which will launch a test server at http://localhost:8000
+
+class Mechanize::TestCase < Minitest::Test
+
+  TEST_DIR = File.expand_path '../../../test', __FILE__
+  REQUESTS = []
+
+  ##
+  # Creates a clean mechanize instance +@mech+ for use in tests.
+
+  def setup
+    super
+
+    REQUESTS.clear
+    @mech = Mechanize.new
+    @ssl_private_key = nil
+    @ssl_certificate = nil
+  end
+
+  ##
+  # Creates a fake page with URI http://fake.example and an empty, submittable
+  # form.
+
+  def fake_page agent = @mech
+    uri = URI 'http://fake.example/'
+    html = <<-END
+<html>
+<body>
+<form><input type="submit" value="submit" /></form>
+</body>
+</html>
+    END
+
+    Mechanize::Page.new uri, nil, html, 200, agent
+  end
+
+  ##
+  # Is the Encoding constant defined?
+
+  def have_encoding?
+    Object.const_defined? :Encoding
+  end
+
+  ##
+  # Creates a Mechanize::Page with the given +body+
+
+  def html_page body
+    uri = URI 'http://example/'
+    Mechanize::Page.new uri, nil, body, 200, @mech
+  end
+
+  ##
+  # Creates a Mechanize::CookieJar by parsing the given +str+
+
+  def cookie_jar str, uri = URI('http://example')
+    jar = Mechanize::CookieJar.new
+
+    jar.parse str, uri
+
+    jar
+  end
+
+  ##
+  # Runs the block inside a temporary directory
+
+  def in_tmpdir
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do
+        yield
+      end
+    end
+  end
+
+  ##
+  # Creates a Nokogiri Node +element+ with the given +attributes+
+
+  def node element, attributes = {}
+    doc = Nokogiri::HTML::Document.new
+
+    node = Nokogiri::XML::Node.new element, doc
+
+    attributes.each do |name, value|
+      node[name] = value
+    end
+
+    node
+  end
+
+  ##
+  # Creates a Mechanize::Page for the given +uri+ with the given
+  # +content_type+, response +body+ and HTTP status +code+
+
+  def page uri, content_type = 'text/html', body = '', code = 200
+    uri = URI uri unless URI::Generic === uri
+
+    Mechanize::Page.new(uri, { 'content-type' => content_type }, body, code,
+                        @mech)
+  end
+
+  ##
+  # Requests made during this tests
+
+  def requests
+    REQUESTS
+  end
+
+  ##
+  # An SSL private key.  This key is the same across all test runs
+
+  def ssl_private_key
+    @ssl_private_key ||= OpenSSL::PKey::RSA.new <<-KEY
+-----BEGIN RSA PRIVATE KEY-----
+MIG7AgEAAkEA8pmEfmP0Ibir91x6pbts4JmmsVZd3xvD5p347EFvBCbhBW1nv1Gs
+bCBEFlSiT1q2qvxGb5IlbrfdhdgyqdTXUQIBAQIBAQIhAPumXslvf6YasXa1hni3
+p80joKOug2UUgqOLD2GUSO//AiEA9ssY6AFxjHWuwo/+/rkLmkfO2s1Lz3OeUEWq
+6DiHOK8CAQECAQECIQDt8bc4vS6wh9VXApNSKIpVygtxSFe/IwLeX26n77j6Qg==
+-----END RSA PRIVATE KEY-----
+    KEY
+  end
+
+  ##
+  # An X509 certificate.  This certificate is the same across all test runs
+
+  def ssl_certificate
+    @ssl_certificate ||= OpenSSL::X509::Certificate.new <<-CERT
+-----BEGIN CERTIFICATE-----
+MIIBQjCB7aADAgECAgEAMA0GCSqGSIb3DQEBBQUAMCoxDzANBgNVBAMMBm5vYm9k
+eTEXMBUGCgmSJomT8ixkARkWB2V4YW1wbGUwIBcNMTExMTAzMjEwODU5WhgPOTk5
+OTEyMzExMjU5NTlaMCoxDzANBgNVBAMMBm5vYm9keTEXMBUGCgmSJomT8ixkARkW
+B2V4YW1wbGUwWjANBgkqhkiG9w0BAQEFAANJADBGAkEA8pmEfmP0Ibir91x6pbts
+4JmmsVZd3xvD5p347EFvBCbhBW1nv1GsbCBEFlSiT1q2qvxGb5IlbrfdhdgyqdTX
+UQIBATANBgkqhkiG9w0BAQUFAANBAAAB////////////////////////////////
+//8AMCEwCQYFKw4DAhoFAAQUePiv+QrJxyjtEJNnH5pB9OTWIqA=
+-----END CERTIFICATE-----
+    CERT
+  end
+
+  ##
+  # Creates a Tempfile with +content+ that is immediately unlinked
+
+  def tempfile content
+    body_io = Tempfile.new @NAME
+    body_io.unlink
+    body_io.write content
+    body_io.flush
+    body_io.rewind
+
+    body_io
+  end
+
+end
+
+require 'mechanize/test_case/servlets'
+
+module Net # :nodoc:
+end
+
+class Net::HTTP # :nodoc:
+  alias :old_do_start :do_start
+
+  def do_start
+    @started = true
+  end
+
+  PAGE_CACHE = {}
+
+  alias :old_request :request
+
+  def request(req, *data, &block)
+    url = URI.parse(req.path)
+    path = WEBrick::HTTPUtils.unescape(url.path)
+
+    path = '/index.html' if path == '/'
+
+    res = ::Response.new
+    res.query_params = url.query
+
+    req.query = if 'POST' != req.method && url.query then
+                  WEBrick::HTTPUtils.parse_query url.query
+                elsif req['content-type'] =~ /www-form-urlencoded/ then
+                  WEBrick::HTTPUtils.parse_query req.body
+                elsif req['content-type'] =~ /boundary=(.+)/ then
+                  boundary = WEBrick::HTTPUtils.dequote $1
+                  WEBrick::HTTPUtils.parse_form_data req.body, boundary
+                else
+                  {}
+                end
+
+    req.cookies = WEBrick::Cookie.parse(req['Cookie'])
+
+    Mechanize::TestCase::REQUESTS << req
+
+    if servlet_klass = MECHANIZE_TEST_CASE_SERVLETS[path]
+      servlet = servlet_klass.new({})
+      servlet.send "do_#{req.method}", req, res
+    else
+      filename = "htdocs#{path.gsub(/[^\/\\.\w\s]/, '_')}"
+      unless PAGE_CACHE[filename]
+        open("#{Mechanize::TestCase::TEST_DIR}/#{filename}", 'rb') { |io|
+          PAGE_CACHE[filename] = io.read
+        }
+      end
+
+      res.body = PAGE_CACHE[filename]
+      case filename
+      when /\.txt$/
+        res['Content-Type'] = 'text/plain'
+      when /\.jpg$/
+        res['Content-Type'] = 'image/jpeg'
+      end
+    end
+
+    res['Content-Type'] ||= 'text/html'
+    res.code ||= "200"
+
+    response_klass = Net::HTTPResponse::CODE_TO_OBJ[res.code.to_s]
+    response = response_klass.new res.http_version, res.code, res.message
+
+    res.header.each do |k,v|
+      v = v.first if v.length == 1
+      response[k] = v
+    end
+
+    res.cookies.each do |cookie|
+      response.add_field 'Set-Cookie', cookie.to_s
+    end
+
+    response['Content-Type'] ||= 'text/html'
+    response['Content-Length'] = res['Content-Length'] || res.body.length.to_s
+
+    io = StringIO.new(res.body)
+    response.instance_variable_set :@socket, io
+    def io.read clen, dest = nil, _ = nil
+      if dest then
+        dest << super(clen)
+      else
+        super clen
+      end
+    end
+
+    body_exist = req.response_body_permitted? &&
+      response_klass.body_permitted?
+
+    response.instance_variable_set :@body_exist, body_exist
+
+    yield response if block_given?
+
+    response
+  end
+end
+
+class Net::HTTPRequest # :nodoc:
+  attr_accessor :query, :body, :cookies, :user
+
+  def host
+    'example'
+  end
+
+  def port
+    80
+  end
+end
+
+class Response # :nodoc:
+  include Net::HTTPHeader
+
+  attr_reader :code
+  attr_accessor :body, :query, :cookies
+  attr_accessor :query_params, :http_version
+  attr_accessor :header
+
+  def code=(c)
+    @code = c.to_s
+  end
+
+  alias :status :code
+  alias :status= :code=
+
+    def initialize
+      @header = {}
+      @body = ''
+      @code = nil
+      @query = nil
+      @cookies = []
+      @http_version = '1.1'
+    end
+
+  def read_body
+    yield body
+  end
+
+  def message
+    ''
+  end
+end
+