hurley 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70bb285608ba9cef1503ea1acf003fbdc48c0648
+  data.tar.gz: 0b9e00c2e5880c432c41865ed996cffdb9174d46
+SHA512:
+  metadata.gz: a9d694cf97f96c3099171fa5479b6c2ad5e3037ec02fa53776945a1b1166e45084e13508c660d5948e2c4b4445fa29020eae28e2187f1474629e28c05509b324
+  data.tar.gz: f48211a98ac3616638afbdd58c5b95dca7e6e486cf2eec6503147321ea628c2f6bbe082840568cff4923e865f9842247aadf5d3c3a352fe2b69a0b887660317a

data/.gitignore

@@ -0,0 +1,4 @@
+log
+tmp
+pkg
+

data/.travis.yml

@@ -0,0 +1,28 @@
+sudo: false
+language: ruby
+install: script/bootstrap
+script: script/test
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - jruby-18mode
+  - jruby-19mode
+  - jruby-head
+
+matrix:
+  allow_failures:
+    # "A fatal error has been detected by the Java Runtime Environment:
+    #  Internal Error (sharedRuntime.cpp:843)"
+    - rvm: jruby-18mode
+    - rvm: jruby-19mode
+    - rvm: jruby-head
+    # random crashes
+  fast_finish: true
+
+env:
+  matrix:
+    - HURLEY_SSL=no
+    - HURLEY_SSL=yes
+    - HURLEY_SSL=no HURLEY_ADDRESSABLE=1
+    - HURLEY_SSL=yes HURLEY_ADDRESSABLE=1

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    hurley (0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.6)
+    minitest (5.5.0)
+    rack (1.6.0)
+    rack-protection (1.5.3)
+      rack
+    sinatra (1.4.5)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    tilt (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  addressable (~> 2.3.6)
+  bundler (~> 1.0)
+  hurley!
+  minitest (~> 5.5.0)
+  sinatra (~> 1.4.5)

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Rick Olson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,317 @@
+# Hurley
+
+![](http://comicstheblog.com/wp-content/uploads/2013/10/Hurley-Run.gif)
+
+Hurley is a ruby gem with no runtime dependencies that provides a common
+interface for working with different HTTP adapters. It is an evolution of
+Faraday, with rethought internals.
+
+Hurley revolves around three main classes: Client, Request, and Response.  A
+Client sets the default properties for all HTTP requests, including the base
+url, headers, and options.
+
+```ruby
+require "hurley"
+
+# If you prefer Addressable::URI, require this too:
+# This is required automatically if `Addressable::URI` is defined when Hurley
+# is being loaded.
+require "hurley/addressable"
+
+client = Hurley::Client.new "https://api.github.com"
+client.header[:accept] = "application/vnd.github+json"
+client.query["a"] = "?a is set on every request too"
+
+client.scheme # => "https"
+client.host   # => "api.github.com"
+client.port   # => 443
+
+# See Hurley::RequestOptions in lib/hurley/options.rb
+client.request_options.timeout = 3
+
+# See Hurley::SslOptions in lib/hurley/options.rb
+client.ssl_options.ca_file = "path/to/cert.crt"
+
+# Verbs head, get, put, post, patch, delete, and options are supported.
+response = client.get("users/tater") do |req|
+  # These properties can be changed on a per-request basis.
+  req.header[:accept] = "application/vnd.github.preview+json"
+  req.query["a"] = "override!"
+
+  req.options.timeout = 1
+  req.ssl_options.ca_file = "path/to/cert.crt"
+
+  req.verb   # => :get
+  req.scheme # => "https"
+  req.host   # => "api.github.com"
+  req.port   # => 443
+end
+
+# You can also use Hurley class level shortcuts, which use Hurley.default_client.
+response = Hurley.get("https://api.github.com/users/tater")
+
+response.header[:content_type] # => "application/json"
+response.status_code           # => 200
+response.body                  # => {"id": 1, ...}
+response.request               # => same as `request`
+
+# Is this a 2xx response?
+response.success?
+
+# Is this a 3xx redirect?
+response.redirection?
+
+# Is this is a 4xx response?
+response.client_error?
+
+# Is this a 5xx response?
+response.server_error?
+
+# What kind of response is this?
+response.status_type # => One of :success, :redirection, :client_error, :server_error, or :other
+
+# Timing of the response, in ms
+response.ms
+
+# Responses automatically follow 5 redirections by default.
+
+response.via      # Array of Request objects that redirected.
+response.location # => New Request built from Location header URL.
+
+# You can tune the number of redirections, or disable them per Client or Request.
+
+# This client follows up to 10 redirects
+client.request_options.redirection_limit = 10
+client.get "/foo" do |req|
+  # this specific request never follows any redirects.
+  req.options.redirection_limit = 0
+end
+```
+
+## Connections
+
+By default, a `Hurley::Client` uses a `Hurley::Connection` instance to make
+requests with net/http.  You can swap the connection with any object that
+responds to `#call` with a Request, and returns a Response.  This will not
+interrupt other client properties or callbacks.
+
+```ruby
+client = Hurley::Client.new "https://api.github.com"
+client.connection = lambda do |req|
+  # return a Hurley::Response!
+end
+```
+
+## URLs
+
+Hurley joins a Client endpoint with a given request URL to produce the final
+URL that is requested.
+
+```ruby
+client = Hurley::Client.new "https://a:b@api.com/v1?a=1"
+
+client.get "user" do |req|
+  req.url.user     # => "a"
+  req.url.password # => "b"
+  req.url          # https://api.com/v1/user?a=1
+end
+
+# Absolute paths remove any path prefix
+client.get "/v2/user" do |req|
+  req.url.user     # => "a"
+  req.url.password # => "b"
+  req.url          # https://api.com/v2/user?a=1
+end
+
+client.get "user?a=2" do |req|
+  req.url.user     # => "a"
+  req.url.password # => "b"
+  req.url          # https://api.com/v1/user?a=2
+end
+
+# Basic auth can be overridden
+client.get "https://c:d@api.com/v1/user" do |req|
+  req.url.user     # => "c"
+  req.url.password # => "d"
+  req.url          # https://api.com/v1/user?a=1
+end
+
+client.get "https://staging.api.com/v1/user" do |req|
+  req.url.user     # => nil, since the host changed
+  req.url.password # => nil
+  req.url          # https://staging.api.com/v1/user
+end
+```
+
+Hurley uses `Hurley::Query::Nested` for all query encoding and decoding by
+default.  This can be changed globally, per client, or per request.  Typically
+you won't create `Hurley::Query` instances manually, and will use
+`Hurley::Query.parse` for parsing.
+
+```ruby
+# Nested queries
+
+q = Hurley::Query::Nested.new(:a => [1,2], :h => {:a => 1})
+q.to_query_string # => "a[]=1&a[]=2&h[a]=1"
+
+Hurley::Query::Nested.parse(q.to_query_string)
+# => #<Hurley::Query::Nested {"a"=>["1", "2"], "h"=>{"a"=>"1"}}>
+
+# Flat queries
+
+q = Hurley::Query::Flat.new(:a => [1,2])
+q.to_query_string # => "a=1&a=2"
+
+Hurley::Query::Flat.parse(q.to_query_string)
+# => #<Hurley::Query::Nested {"a"=>["1", "2"]}>
+
+# Change it globally.
+Hurley.default = Hurley::Query::Flat
+
+# Change it for just this client.
+client = Hurley::Client.new
+client.request_options.query_class = Hurley::Query::Flat
+
+# Change it for just this request.
+client.get "/foo" do |req|
+  req.options.query_class = Hurley::Query::Flat
+end
+```
+
+## Headers
+
+A Client's Header is passed down to each request.  Header keys can be overridden
+by the request.  Headers are stored internally in canonical form, which is
+capitalized with dashes: `"Content-Type"`, for example.
+
+See `Hurley::Header` for all of the common header keys that have symbolized
+shortcuts.
+
+```ruby
+client = Hurley::Client.new "https://api.com"
+client.header[:content_type] = "application/json"
+
+# Same as:
+client.header["content-type"] = "application/json"
+client.header["Content-Type"] = "application/json"
+
+client.get "/something.atom" do |req|
+  # Default user agent
+  req.header[:user_agent] # => "Hurley v#{Hurley::VERSION}"
+
+  # Change a header
+  req.header[:content_type] = "application/atom"
+end
+```
+
+## Posting Forms
+
+Hurley will encode form bodies for you, while setting default Content-Type and
+Content-Length values as necessary.  Multipart forms are supported too, using
+`Hurley::UploadIO` objects.
+
+```ruby
+# Works with HTTP verbs: post, put, and patch
+
+# Send a=1 with Content-Type: application/x-www-form-urlencoded
+client.post("/form", :a => 1)
+
+# Send a=1 with Content-Type: text/plain
+client.post("/form", {:a => 1}, "text/plain")
+
+# Send file with Content-Type: multipart/form-data
+client.post("/multipart", :file => Hurley::UploadIO.new("filename.txt", "text/plain"))
+```
+
+The default query parser (`Hurley::Query::Nested`) is used by default.  You can
+change it globally, per client, or per request.  See the "URLs" section.
+
+## Client Callbacks
+
+Clients can define "before callbacks" that yield a Request, or "after callbacks"
+that yield a Response.  Multiple callbacks of the same type are added in order.
+
+```ruby
+client.before_call do |req|
+  # modify request before it's called
+end
+
+client.before_callbacks # => ["#<Proc:...>"]
+
+client.after_call do |res|
+  # modify response after it's called
+end
+
+# You can set a name to identify the callback
+client.before_call :upcase do |req|
+  req.body.upcase!
+end
+
+client.before_callbacks # => [:upcase]
+
+# You can also pass an object that responds to #call and #name.
+class Upcaser
+  def name
+    :upcaser
+  end
+
+  def call(req)
+    req.body.upcase!
+  end
+end
+
+client.before_call(Upcaser.new)
+client.before_callbacks # => [:upcaser]
+```
+
+## Streaming the Response Body
+
+A Request object can take a callback that receives the response body in chunks
+as they are read from the socket.  Hurley connections that don't support
+streaming will yield the entire response body once.
+
+```ruby
+client.get "big-file" do |req|
+  req.on_body do |res, chunk|
+    puts "#{res.status_code}: #{chunk}"
+  end
+
+  # This streams the body for 200 or 201 responses only:
+  req.on_body(200, 201) do |res, chunk|
+    puts "#{res.status_code}: #{chunk}"
+  end
+end
+```
+
+## Testing
+
+Hurley includes a Test connection object for testing.  This lets you make
+requests without hitting a real endpoint.
+
+```ruby
+require "hurley"
+require "hurley/test"
+
+client = Hurley::Client.new "https://api.github.com"
+
+client.connection = Hurley::Test.new do |test|
+  # Verbs head, get, put, post, patch, delete, and options are supported.
+  test.get "/user" do |req|
+    # req is a Hurley::Request
+    # Return a Rack-compatible response.
+    [200, {"Content-Type" => "application/json"}, %({"id": 1})]
+  end
+end
+
+client.get("/user").body # => {"id": 1}
+```
+
+## TODO
+
+* [ ] Backport Faraday adapters as gems
+* [ ] Integrate into Faraday reliant gems:
+  * [ ] [Sawyer](https://github.com/lostisland/sawyer)
+  * [ ] [Octokit](https://github.com/octokit/octokit.rb)
+  * [ ] [Elastomer](https://github.com/github/elastomer-client)
+* [ ] Fix allll the bugs
+* [ ] Release v1.0

data/Rakefile

@@ -0,0 +1 @@
+require File.expand_path("../lib/hurley/tasks", __FILE__)

data/contributors.yaml

@@ -0,0 +1,8 @@
+# Contributors
+# https://github.com/orgs/lostisland/teams/owners
+# https://github.com/orgs/lostisland/teams/faraday-collaborators
+# Change your name, or add your email if you want to be credited in the gemspec.
+# Ordered according to https://github.com/lostisland/hurley/graphs/contributors
+Rick Olson: technoweenie@gmail.com
+Wynn Netherland:
+Ben Maraney:

data/hurley.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = "hurley"
+lib_file = File.expand_path("../lib/#{lib}.rb", __FILE__)
+File.read(lib_file) =~ /\bVERSION\s*=\s*["'](.+?)["']/
+version = $1
+
+require "yaml"
+contributors = YAML.load(IO.read(File.expand_path("../contributors.yaml", __FILE__)))
+
+Gem::Specification.new do |spec|
+  spec.add_development_dependency "addressable", "~> 2.3", ">= 2.3.6"
+  spec.add_development_dependency "bundler", "~> 1.0"
+  spec.add_development_dependency "minitest", "~> 5.5", ">= 5.5.0"
+  spec.add_development_dependency "rake", "~> 10.4.0", ">= 10.4.2"
+  spec.add_development_dependency "sinatra", "~> 1.4", ">= 1.4.5"
+  spec.authors = contributors.keys.compact
+  spec.description = %q{Hurley provides a common interface for working with different HTTP adapters.}
+  spec.email = contributors.values.compact
+  spec.homepage = "https://github.com/lostisland/hurley"
+  dev_null = File.exist?("/dev/null") ? "/dev/null" : "NUL"
+  git_files = `git ls-files -z 2>#{dev_null}`
+  spec.files = git_files.split("\0") if $?.success?
+  spec.test_files = Dir.glob("test/**/*.rb")
+  spec.licenses = ["MIT"]
+  spec.name = lib
+  spec.require_paths = ["lib"]
+  spec.summary = "HTTP client wrapper"
+  spec.version = version
+end