RubyGems - search_biomodel - Versions diffs - 1.0.0 → 1.0.1 - Mend

search_biomodel 1.0.0 → 1.0.1

Files changed (1054) hide show

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/README.md DELETED Viewed

@@ -1,223 +0,0 @@
-HTTPI [![Build Status](http://travis-ci.org/rubiii/httpi.png)](http://travis-ci.org/rubiii/httpi)
-=====
-HTTPI provides a common interface for Ruby HTTP libraries.
-[Bugs](http://github.com/rubiii/httpi/issues) | [RDoc](http://rubydoc.info/gems/httpi/frames)
-Installation
-------------
-HTTPI is available through [Rubygems](http://rubygems.org/gems/httpi) and can be installed via:
-```
-$ gem install httpi
-```
-Getting started
----------------
-In order to provide a common interface, HTTPI provides the `HTTPI::Request` object for you to
-configure your request. Here's a very simple GET request.
-``` ruby
-request = HTTPI::Request.new("http://example.com")
-HTTPI.get request
-```
-To execute a POST request, you may want to specify a payload.
-``` ruby
-request = HTTPI::Request.new
-request.url = "http://post.example.com"
-request.body = "some data"
-HTTPI.post request
-```
-HTTPI
------
-The `HTTPI` module uses one of the available adapters to execute HTTP requests.
-#### GET
-``` ruby
-HTTPI.get(request, adapter = nil)
-HTTPI.get(url, adapter = nil)
-```
-#### POST
-``` ruby
-HTTPI.post(request, adapter = nil)
-HTTPI.post(url, body, adapter = nil)
-```
-#### HEAD
-``` ruby
-HTTPI.head(request, adapter = nil)
-HTTPI.head(url, adapter = nil)
-```
-#### PUT
-``` ruby
-HTTPI.put(request, adapter = nil)
-HTTPI.put(url, body, adapter = nil)
-```
-#### DELETE
-``` ruby
-HTTPI.delete(request, adapter = nil)
-HTTPI.delete(url, adapter = nil)
-```
-#### Notice
-* You can specify the adapter to use per request
-* And request methods always return an `HTTPI::Response`
-#### More control
-If you need more control over the request, you can access the HTTP client instance
-represented by your adapter in a block:
-``` ruby
-HTTPI.post request do |http|
-  http.use_ssl = true  # Curb example
-end
-```
-HTTPI::Adapter
---------------
-HTTPI uses adapters to support multiple HTTP libraries.
-It currently contains adapters for:
-* [httpclient](http://rubygems.org/gems/httpclient) ~> 2.1.5
-* [curb](http://rubygems.org/gems/curb) ~> 0.7.8
-* [net/http](http://ruby-doc.org/stdlib/libdoc/net/http/rdoc)
-You can manually specify the adapter to use via:
-``` ruby
-HTTPI.adapter = :curb  # or one of [:httpclient, :net_http]
-```
-If you don't specify which adapter to use, HTTPI try to load HTTPClient, then Curb and finally NetHTTP.
-#### Notice
-HTTPI does not force you to install any of these libraries. If you'd like to use on of the more advanced
-libraries (HTTPClient or Curb), you have to make sure they're in your LOAD_PATH. HTTPI will then load the
-library when executing HTTP requests.
-HTTPI::Request
---------------
-#### URL
-``` ruby
-request.url = "http://example.com"
-request.url # => #<URI::HTTP:0x101c1ab18 URL:http://example.com>
-```
-#### Proxy
-``` ruby
-request.proxy = "http://example.com"
-request.proxy # => #<URI::HTTP:0x101c1ab18 URL:http://example.com>
-```
-#### Headers
-``` ruby
-request.headers["Accept-Charset"] = "utf-8"
-request.headers = { "Accept-Charset" => "utf-8" }
-request.headers # => { "Accept-Charset" => "utf-8" }
-```
-#### Body
-``` ruby
-request.body = "some data"
-request.body # => "some data"
-```
-#### Open timeout
-``` ruby
-request.open_timeout = 30 # sec
-```
-#### Read timeout
-``` ruby
-request.read_timeout = 30 # sec
-```
-HTTPI::Auth
------------
-`HTTPI::Auth` supports HTTP basic and digest authentication.
-``` ruby
-request.auth.basic("username", "password")   # HTTP basic auth credentials
-request.auth.digest("username", "password")  # HTTP digest auth credentials
-request.auth.ntlm("username", "password")    # NTLM auth credentials
-```
-HTTPI::Auth::SSL
-----------------
-`HTTPI::Auth::SSL` manages SSL client authentication.
-``` ruby
-request.auth.ssl.cert_key_file     = "client_key.pem"   # the private key file to use
-request.auth.ssl.cert_key_password = "C3rtP@ssw0rd"     # the key file's password
-request.auth.ssl.cert_file         = "client_cert.pem"  # the certificate file to use
-request.auth.ssl.ca_cert_file      = "ca_cert.pem"      # the ca certificate file to use
-request.auth.ssl.verify_mode       = :none              # or one of [:peer, :fail_if_no_peer_cert, :client_once]
-```
-HTTPI::Response
----------------
-Every request returns an `HTTPI::Response`. It contains the response code, headers and body.
-``` ruby
-response = HTTPI.get request
-response.code     # => 200
-response.headers  # => { "Content-Encoding" => "gzip" }
-response.body     # => "<!DOCTYPE HTML PUBLIC ...>"
-```
-The `response.body` handles gzipped and [DIME](http://en.wikipedia.org/wiki/Direct_Internet_Message_Encapsulation) encoded responses.
-#### TODO
-* Return the original `HTTPI::Request` for debugging purposes
-* Return the time it took to execute the request
-Logging
--------
-HTTPI by default logs each HTTP request to STDOUT using a log level of :debug.
-``` ruby
-HTTPI.log       = false     # disable logging
-HTTPI.logger    = MyLogger  # change the logger
-HTTPI.log_level = :info     # change the log level
-```

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/Rakefile DELETED Viewed

@@ -1,18 +0,0 @@
-require "bundler"
-Bundler::GemHelper.install_tasks
-require "rspec/core/rake_task"
-RSpec::Core::RakeTask.new do |t|
-  t.pattern = "spec/httpi/**/*_spec.rb"
-  t.rspec_opts = %w(-fd -c)
-end
-desc "Run RSpec integration examples"
-RSpec::Core::RakeTask.new "spec:integration" do |t|
-  t.pattern = "spec/integration/*_spec.rb"
-  t.rspec_opts = %w(-fd -c)
-end
-task :default => :spec
-task :test => :spec

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/autotest/discover.rb DELETED Viewed

	@@ -1 +0,0 @@
1	- Autotest.add_discovery { "rspec2" }

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/httpi.gemspec DELETED Viewed

@@ -1,28 +0,0 @@
-lib = File.expand_path("../lib/", __FILE__)
-$:.unshift lib unless $:.include?(lib)
-require "httpi/version"
-Gem::Specification.new do |s|
-  s.name        = "httpi"
-  s.version     = HTTPI::VERSION
-  s.authors     = ["Daniel Harrington", "Martin Tepper"]
-  s.email       = "me@rubiii.com"
-  s.homepage    = "http://github.com/rubiii/#{s.name}"
-  s.summary     = "Interface for Ruby HTTP libraries"
-  s.description = "HTTPI provides a common interface for Ruby HTTP libraries."
-  s.rubyforge_project = s.name
-  s.add_dependency "rack"
-  s.add_dependency "pyu-ntlm-http",           ">= 0.1.3.1"
-  s.add_development_dependency "rspec",       "~> 2.2"
-  s.add_development_dependency "autotest"
-  s.add_development_dependency "mocha",       "~> 0.9.9"
-  s.add_development_dependency "webmock",     "~> 1.4.0"
-  s.add_development_dependency "mock-server", "~> 0.1.1"
-  s.files = `git ls-files`.split("\n")
-  s.require_path = "lib"
-end

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/lib/httpi/adapter/curb.rb DELETED Viewed

@@ -1,125 +0,0 @@
-require "httpi/response"
-module HTTPI
-  module Adapter
-    # = HTTPI::Adapter::Curb
-    #
-    # Adapter for the Curb client.
-    # http://rubygems.org/gems/curb
-    class Curb
-      def initialize(request = nil)
-      end
-      # Returns a memoized <tt>Curl::Easy</tt> instance.
-      def client
-        @client ||= Curl::Easy.new
-      end
-      # Executes an HTTP GET request.
-      # @see HTTPI.get
-      def get(request)
-        do_request(request) { |client| client.http_get }
-      end
-      # Executes an HTTP POST request.
-      # @see HTTPI.post
-      def post(request)
-        do_request(request) { |client| client.http_post request.body }
-      end
-      # Executes an HTTP HEAD request.
-      # @see HTTPI.head
-      def head(request)
-        do_request(request) { |client| client.http_head }
-      end
-      # Executes an HTTP PUT request.
-      # @see HTTPI.put
-      def put(request)
-        do_request(request) { |client| client.http_put request.body }
-      end
-      # Executes an HTTP DELETE request.
-      # @see HTTPI.delete
-      def delete(request)
-        do_request(request) { |client| client.http_delete }
-      end
-    private
-      def do_request(request)
-        setup_client request
-        yield client
-        respond_with client
-      end
-      def setup_client(request)
-        basic_setup request
-        setup_http_auth request if request.auth.http?
-        setup_ssl_auth request.auth.ssl if request.auth.ssl?
-        setup_ntlm_auth request if request.auth.ntlm?
-      end
-      def basic_setup(request)
-        client.url = request.url.to_s
-        client.proxy_url = request.proxy.to_s if request.proxy
-        client.timeout = request.read_timeout if request.read_timeout
-        client.connect_timeout = request.open_timeout if request.open_timeout
-        client.headers = request.headers.to_hash
-        client.verbose = false
-      end
-      def setup_http_auth(request)
-        client.http_auth_types = request.auth.type
-        client.username, client.password = *request.auth.credentials
-      end
-      def setup_ssl_auth(ssl)
-        client.cert_key = ssl.cert_key_file
-        client.cert = ssl.cert_file
-        client.cacert = ssl.ca_cert_file if ssl.ca_cert_file
-        client.certtype = ssl.cert_type.to_s.upcase
-        client.ssl_verify_peer = ssl.verify_mode == :peer
-      end
-      def setup_ntlm_auth(request)
-        client.username, client.password = *request.auth.credentials
-        client.http_auth_types = request.auth.type
-      end
-      def respond_with(client)
-        status, headers = parse_header_string(client.header_str)
-        Response.new client.response_code, headers, client.body_str
-      end
-      # Borrowed from Webmock's Curb adapter:
-      # http://github.com/bblimke/webmock/blob/master/lib/webmock/http_lib_adapters/curb.rb
-      def parse_header_string(header_string)
-        status, headers = nil, {}
-        return [status, headers] unless header_string
-        header_string.split(/\r\n/).each do |header|
-          if header =~ %r|^HTTP/1.[01] \d\d\d (.*)|
-            status = $1
-          else
-            parts = header.split(':', 2)
-            unless parts.empty?
-              parts[1].strip! unless parts[1].nil?
-              if headers.has_key?(parts[0])
-                headers[parts[0]] = [headers[parts[0]]] unless headers[parts[0]].kind_of? Array
-                headers[parts[0]] << parts[1]
-              else
-                headers[parts[0]] = parts[1]
-              end
-            end
-          end
-        end
-        [status, headers]
-      end
-    end
-  end
-end

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/lib/httpi/adapter/httpclient.rb DELETED Viewed

@@ -1,98 +0,0 @@
-require "httpi/response"
-module HTTPI
-  module Adapter
-    # = HTTPI::Adapter::HTTPClient
-    #
-    # Adapter for the HTTPClient client.
-    # http://rubygems.org/gems/httpclient
-    class HTTPClient
-      def initialize(request = nil)
-      end
-      # Returns a memoized <tt>HTTPClient</tt> instance.
-      def client
-        @client ||= ::HTTPClient.new
-      end
-      # Executes an HTTP GET request.
-      # @see HTTPI.get
-      def get(request)
-        do_request request do |url, headers|
-          client.get url, nil, headers
-        end
-      end
-      # Executes an HTTP POST request.
-      # @see HTTPI.post
-      def post(request)
-        do_request request do |url, headers, body|
-          client.post url, body, headers
-        end
-      end
-      # Executes an HTTP HEAD request.
-      # @see HTTPI.head
-      def head(request)
-        do_request request do |url, headers|
-          client.head url, nil, headers
-        end
-      end
-      # Executes an HTTP PUT request.
-      # @see HTTPI.put
-      def put(request)
-        do_request request do |url, headers, body|
-          client.put url, body, headers
-        end
-      end
-      # Executes an HTTP DELETE request.
-      # @see HTTPI.delete
-      def delete(request)
-        do_request request do |url, headers|
-          client.delete url, headers
-        end
-      end
-    private
-      def do_request(request)
-        setup_client request
-        respond_with yield(request.url, request.headers, request.body)
-      end
-      def setup_client(request)
-        basic_setup request
-        setup_auth request if request.auth.http? || request.auth.ntlm?
-        setup_ssl_auth request.auth.ssl if request.auth.ssl?
-      end
-      def basic_setup(request)
-        client.proxy = request.proxy if request.proxy
-        client.connect_timeout = request.open_timeout if request.open_timeout
-        client.receive_timeout = request.read_timeout if request.read_timeout
-      end
-      def setup_auth(request)
-        client.set_auth request.url, *request.auth.credentials
-      end
-      def setup_ssl_auth(ssl)
-        unless ssl.verify_mode == :none
-          client.ssl_config.client_cert = ssl.cert
-          client.ssl_config.client_key = ssl.cert_key
-          client.ssl_config.client_ca = ssl.ca_cert if ssl.ca_cert_file
-        end
-        client.ssl_config.verify_mode = ssl.openssl_verify_mode
-      end
-      def respond_with(response)
-        Response.new response.code, Hash[*response.header.all.flatten], response.content
-      end
-    end
-  end
-end

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/lib/httpi/adapter/net_http.rb DELETED Viewed

@@ -1,117 +0,0 @@
-require "uri"
-require "httpi/response"
-module HTTPI
-  module Adapter
-    # = HTTPI::Adapter::NetHTTP
-    #
-    # Adapter for the Net::HTTP client.
-    # http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/
-    class NetHTTP
-      def initialize(request)
-        self.client = new_client request
-      end
-      attr_reader :client
-      # Executes an HTTP GET request.
-      # @see HTTPI.get
-      def get(request)
-        do_request :get, request do |http, get|
-          http.request get
-        end
-      end
-      # Executes an HTTP POST request.
-      # @see HTTPI.post
-      def post(request)
-        do_request :post, request do |http, post|
-          post.body = request.body
-          http.request post
-        end
-      end
-      # Executes an HTTP HEAD request.
-      # @see HTTPI.head
-      def head(request)
-        do_request :head, request do |http, head|
-          http.request head
-        end
-      end
-      # Executes an HTTP PUT request.
-      # @see HTTPI.put
-      def put(request)
-        do_request :put, request do |http, put|
-          put.body = request.body
-          http.request put
-        end
-      end
-      # Executes an HTTP DELETE request.
-      # @see HTTPI.delete
-      def delete(request)
-        do_request :delete, request do |http, delete|
-          http.request delete
-        end
-      end
-    private
-      attr_writer :client
-      def new_client(request)
-        proxy = request.proxy || URI("")
-        Net::HTTP::Proxy(proxy.host, proxy.port).new request.url.host, request.url.port
-      end
-      def do_request(type, request)
-        setup_client request
-        setup_ssl_auth request.auth.ssl if request.auth.ssl?
-        respond_with(client.start do |http|
-          yield http, request_client(type, request)
-        end)
-      end
-      def setup_client(request)
-        client.use_ssl = request.ssl?
-        client.open_timeout = request.open_timeout if request.open_timeout
-        client.read_timeout = request.read_timeout if request.read_timeout
-      end
-      def setup_ssl_auth(ssl)
-        client.key = ssl.cert_key
-        client.cert = ssl.cert
-        client.ca_file = ssl.ca_cert_file if ssl.ca_cert_file
-        client.verify_mode = ssl.openssl_verify_mode
-      end
-      def request_client(type, request)
-        request_class = case type
-          when :get    then Net::HTTP::Get
-          when :post   then Net::HTTP::Post
-          when :head   then Net::HTTP::Head
-          when :put    then Net::HTTP::Put
-          when :delete then Net::HTTP::Delete
-        end
-        request_client = request_class.new request.url.request_uri, request.headers
-        request_client.basic_auth *request.auth.credentials if request.auth.basic?
-        request_client.ntlm_auth *request.auth.credentials if request.auth.ntlm?
-        request_client
-      end
-      def respond_with(response)
-        headers = response.to_hash
-        headers.each { |key, value| headers[key] = value[0] }
-        Response.new response.code, headers, response.body
-      end
-    end
-  end
-end

data/search_biomodel/ruby/1.8/gems/httpi-0.9.4/lib/httpi/adapter.rb DELETED Viewed

@@ -1,67 +0,0 @@
-require "httpi/adapter/httpclient"
-require "httpi/adapter/curb"
-require "httpi/adapter/net_http"
-module HTTPI
-  # = HTTPI::Adapter
-  #
-  # Manages the adapter classes. Currently supports:
-  #
-  # * httpclient
-  # * curb
-  # * net/http
-  module Adapter
-    ADAPTERS = {
-      :httpclient => { :class => HTTPClient, :dependencies => ["httpclient"] },
-      :curb       => { :class => Curb,       :dependencies => ["curb"] },
-      :net_http   => { :class => NetHTTP,    :dependencies => ["net/https", "net/ntlm_http"] }
-    }
-    LOAD_ORDER = [:httpclient, :curb, :net_http]
-    class << self
-      def use=(adapter)
-        return @adapter = nil if adapter.nil?
-        validate_adapter! adapter
-        load_dependencies adapter
-        @adapter = adapter
-      end
-      def use
-        @adapter ||= default_adapter
-      end
-      def load(adapter)
-        adapter = adapter ? validate_adapter!(adapter) : use
-        [adapter, ADAPTERS[adapter][:class]]
-      end
-    private
-      def validate_adapter!(adapter)
-        raise ArgumentError, "Invalid HTTPI adapter: #{adapter}" unless ADAPTERS[adapter]
-        adapter
-      end
-      def default_adapter
-        LOAD_ORDER.each do |adapter|
-          begin
-            load_dependencies adapter
-            return adapter
-          rescue LoadError
-            next
-          end
-        end
-      end
-      def load_dependencies(adapter)
-        ADAPTERS[adapter][:dependencies].each { |dependency| require dependency }
-      end
-    end
-  end
-end