weary 1.0.1 → 1.1.0

data/.gitignore

@@ -4,3 +4,4 @@ doc/
 .bundle/
 .yardoc/
 .rbenv-version
+*.rbc

data/Gemfile

@@ -3,17 +3,22 @@ source "http://rubygems.org"
 gemspec
 
 gem "rake", "~> 0.9.2"
+gem "excon"
 
 group :test do
-  gem "rspec", "~> 2.9.0"
-  gem "webmock", "~> 1.8.5"
+  gem "rspec", "~> 2.11.0"
+  gem "webmock", "~> 1.8.10"
 end
 
 group :doc do
-  gem "yard", "~> 0.7.5"
-  gem "yard-tomdoc", "~> 0.4.0"
+  gem "yard", "~> 0.8.2"
+  gem "yard-tomdoc", "~> 0.5.0"
 end
 
 platforms :jruby do
   gem "jruby-openssl"
 end
+
+platforms :mri, :jruby do
+  gem "typhoeus"
+end

data/Gemfile.lock

@@ -2,8 +2,8 @@ PATH
   remote: .
   specs:
     weary (1.0.1)
-      addressable (~> 2.2.7)
-      multi_json (~> 1.2.0)
+      addressable (~> 2.3.2)
+      multi_json (~> 1.3.0)
       promise (~> 0.3.0)
       rack (~> 1.4.0)
       simple_oauth (~> 0.1.5)
@@ -11,28 +11,42 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
-    addressable (2.2.7)
+    addressable (2.3.2)
+    courtier (0.2.0)
+      finder
+      loaded
     crack (0.3.1)
     diff-lcs (1.1.3)
-    multi_json (1.2.0)
+    excon (0.16.2)
+    ffi (1.1.5)
+    finder (0.3.0)
+    loaded (0.0.1)
+    mime-types (1.19)
+    multi_json (1.3.6)
     promise (0.3.0)
     rack (1.4.1)
     rake (0.9.2.2)
-    rspec (2.9.0)
-      rspec-core (~> 2.9.0)
-      rspec-expectations (~> 2.9.0)
-      rspec-mocks (~> 2.9.0)
-    rspec-core (2.9.0)
-    rspec-expectations (2.9.0)
+    rc (0.2.0)
+      courtier (= 0.2.0)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
       diff-lcs (~> 1.1.3)
-    rspec-mocks (2.9.0)
-    simple_oauth (0.1.5)
-    tomparse (0.2.0)
-    webmock (1.8.5)
+    rspec-mocks (2.11.2)
+    simple_oauth (0.1.9)
+    tomparse (0.2.1)
+    typhoeus (0.4.2)
+      ffi (~> 1.0)
+      mime-types (~> 1.18)
+    webmock (1.8.10)
       addressable (>= 2.2.7)
       crack (>= 0.1.7)
-    yard (0.7.5)
-    yard-tomdoc (0.4.0)
+    yard (0.8.2.1)
+    yard-tomdoc (0.5.0)
+      rc
       tomparse
       yard
 
@@ -40,10 +54,12 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  excon
   jruby-openssl
   rake (~> 0.9.2)
-  rspec (~> 2.9.0)
+  rspec (~> 2.11.0)
+  typhoeus
   weary!
-  webmock (~> 1.8.5)
-  yard (~> 0.7.5)
-  yard-tomdoc (~> 0.4.0)
+  webmock (~> 1.8.10)
+  yard (~> 0.8.2)
+  yard-tomdoc (~> 0.5.0)

data/README.md

@@ -1,5 +1,7 @@
 # Weary
 
+[![Build Status](https://secure.travis-ci.org/mwunsch/weary.png)](http://travis-ci.org/mwunsch/weary) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/mwunsch/weary)
+
 _Weary is a framework and DSL for building clients for (preferably RESTful) web service APIs._
 
 At its most minimal, Weary is simply some nice syntactic sugar around Net/HTTP.
@@ -56,7 +58,7 @@ end
 
 The DSL provides methods for all of the HTTP verbs (See `Weary::Client::REQUEST_METHODS`). When you instantiate this class, the object will have an instance method named "resource" that will return a `Weary::Request` object set up to perform a "GET" request on "http://host.com/path/to/resource".
 
-You can pass a block these methods for access to the `Weary::Resource`.
+You can pass a block to these methods for access to the `Weary::Resource`.
 
 Further methods in the DSL include:
 
@@ -113,9 +115,15 @@ The method that the Client defines (in the above example, the `client.update` me
 
 ### Weary::Request
 
-No matter how you get there, you'll end up with a Weary::Request object. Call the `perform` method to actually make the request and get back a `Weary::Response`. That's not entirely true `Weary::Request#perform` is asynchronous and non-blocking. It returns a future and will only block once you call a method on the response. You can optionally pass a block that's executed once the response has returned.
+No matter how you get there, you'll end up with a Weary::Request object. Call the `perform` method to actually make the request and get back a `Weary::Response`. That's not entirely true... `Weary::Request#perform` is asynchronous and non-blocking. It returns a future and will only block once you call a method on the response. You can optionally pass a block that's executed once the response has returned.
+
+By default, the request is performed through [Net::HTTP](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/net/http/rdoc/Net/HTTP.html). This is done through `Weary::Adapter::NetHttp`. A `Weary::Adapter` is just a special kind of Rack application. `Request#adapter` allows you to hook up your own. Weary also includes adapters for [Typhoeus](http://typhoeus.github.com/) and [Excon](https://github.com/geemus/excon).
+
+#### Requestable
+
+`Client`, `Resource`, and `Request` include a Module named `Requestable`. Using this module, it's easy to cascade certain pieces of configuration down from the stack.
 
-By default, the request is performed through [Net::HTTP](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/net/http/rdoc/Net/HTTP.html). This is done through `Weary::Adapter::NetHttp`. A `Weary::Adapter` is just a special kind of Rack application. `Request#adapter` allows you to hook up your own.
+For example, you can call `Client#adapter` to change the adapter for all of the resources of that client. Or you can call `Resource#adapter` to change the adapter for requests built for that resource. OR you can call `Request#adapter` to change the adapter for just that request.
 
 ## Rack
 

data/lib/weary/adapter.rb

@@ -1,9 +1,12 @@
 require 'weary/response'
-require 'weary/adapters/net_http'
+
 module Weary
   # An abstract interface. A subclass should be something that actually opens
   # a socket to make the request, e.g. Net/HTTP, Curb, etc.
   module Adapter
+    autoload :NetHttp, 'weary/adapters/net_http'
+    autoload :Excon, 'weary/adapters/excon'
+    autoload :Typhoeus, 'weary/adapters/typhoeus'
 
     def initialize(app=nil)
       @app = app
@@ -19,5 +22,26 @@ module Weary
     def connect(request)
       Rack::Response.new [""], 501, {"Content-Type" => "text/plain"}
     end
+
+    # Modify the headers of an Env to be Capitalized strings with dashes (as
+    # opposed to the CGI-like headers needed by Rack).
+    def normalize_request_headers(env)
+      req_headers = env.reject {|k,v| !k.start_with? "HTTP_" }
+      normalized = req_headers.map do |k, v|
+        new_key = k.sub("HTTP_",'').split('_').map(&:capitalize).join('-')
+        [new_key, v] unless UNWANTED_REQUEST_HEADERS.include? new_key
+      end
+      Hash[normalized]
+    end
+
+    # According to the Rack Spec:
+    # > The header must not contain a Status key...
+    def normalize_response(headers)
+      headers.reject {|k,v| k.downcase == 'status' }
+    end
+
+    protected
+
+    UNWANTED_REQUEST_HEADERS = []
   end
 end

data/lib/weary/adapters/excon.rb

@@ -0,0 +1,36 @@
+require 'excon'
+
+module Weary
+  module Adapter
+    class Excon
+
+      class << self
+        include Weary::Adapter
+
+        def connect(request)
+          connection = ::Excon.new("#{request.scheme}://#{request.host_with_port}")
+          response = connection.request prepare(request)
+          Rack::Response.new response.body, response.status, normalize_response(response.headers)
+        end
+
+        def prepare(request)
+          has_query = !(request.query_string.nil? || request.query_string.empty?)
+          excon_params = { :headers => normalize_request_headers(request.env),
+                           :method  => request.request_method,
+                           :path    => request.path,
+                           :body    => request.body.read }
+          excon_params[:query] if has_query
+          request.body.rewind
+          excon_params
+        end
+      end
+
+      include Weary::Adapter
+
+      def connect(rack_request)
+        self.class.connect(rack_request)
+      end
+
+    end
+  end
+end

data/lib/weary/adapters/net_http.rb

@@ -4,65 +4,47 @@ require 'net/https'
 module Weary
   module Adapter
     class NetHttp
-      include Weary::Adapter
-
-      def self.call(env)
-        connect(Rack::Request.new(env)).finish
-      end
 
-      def self.connect(request)
-        connection = socket(request)
-        response = connection.request prepare(request)
-        Rack::Response.new response.body, response.code, normalize_response(response.to_hash)
-      end
+      class << self
+        include Weary::Adapter
 
-      def self.prepare(request)
-        req_class = request_class(request.request_method)
-        req = req_class.new(request.fullpath, normalize_request_headers(request.env))
-        if req.request_body_permitted? # What's the best way of passing the body?
-          req.body = request.body.read
-          request.body.rewind
+        def connect(request)
+          connection = socket(request)
+          response = connection.request prepare(request)
+          Rack::Response.new response.body || "", response.code, normalize_response(response.to_hash)
         end
-        req.content_type = request.content_type if request.content_type
-        req.content_length = request.content_length if request.content_length
-        req
-      end
 
-      def self.normalize_request_headers(env)
-        req_headers = env.reject {|k,v| !k.start_with? "HTTP_" }
-        normalized = req_headers.map do |k, v|
-          new_key = k.sub("HTTP_",'').split('_').map(&:capitalize).join('-')
-          [new_key, v] unless UNWANTED_REQUEST_HEADERS.include? new_key
+        def prepare(request)
+          req_class = request_class(request.request_method)
+          net_http_req = req_class.new(request.fullpath, normalize_request_headers(request.env))
+          if net_http_req.request_body_permitted? # What's the best way of passing the body?
+            net_http_req.body = request.body.read
+            request.body.rewind
+          end
+          net_http_req.content_type = request.content_type if request.content_type
+          net_http_req.content_length = request.content_length if request.content_length
+          net_http_req
         end
-        Hash[normalized]
-      end
 
-      def self.normalize_response(headers)
-        headers.reject {|k,v| k.downcase == 'status' }
-      end
+        def socket(request)
+          connection = Net::HTTP.new request.host, request.port.to_s
+          connection.use_ssl = request.scheme == 'https'
+          connection.verify_mode = OpenSSL::SSL::VERIFY_NONE if connection.use_ssl?
+          connection
+        end
 
-      def self.socket(request)
-        host = request.env['HTTP_HOST'] || request.env['SERVER_NAME']
-        port = request.env['SERVER_PORT'].to_s
-        connection = Net::HTTP.new host, port
-        connection.use_ssl = request.scheme == 'https'
-        connection.verify_mode = OpenSSL::SSL::VERIFY_NONE if connection.use_ssl?
-        connection
+        def request_class(method)
+          capitalized = method.capitalize
+          Net::HTTP.const_get capitalized
+        end
       end
 
-      def self.request_class(method)
-        capitalized = method.capitalize
-        Net::HTTP.const_get capitalized
-      end
+      include Weary::Adapter
 
-      def call(env)
-        self.class.call(env)
+      def connect(rack_request)
+        self.class.connect(rack_request)
       end
 
-      private
-
-      UNWANTED_REQUEST_HEADERS = []
-
     end
   end
 end

data/lib/weary/adapters/typhoeus.rb

@@ -0,0 +1,32 @@
+require 'typhoeus'
+
+module Weary
+  module Adapter
+    class Typhoeus
+
+      class << self
+        include Weary::Adapter
+
+        def connect(rack_request)
+          response = ::Typhoeus::Request.run(rack_request.url, parameters_for(rack_request))
+          Rack::Response.new response.body, response.code, response.headers_hash
+        end
+
+        def parameters_for(request)
+          typhoeus_params = { :headers => normalize_request_headers(request.env),
+                              :method  => request.request_method.downcase.to_sym,
+                              :body => request.body.read }
+          request.body.rewind
+          typhoeus_params
+        end
+      end
+
+      include Weary::Adapter
+
+      def connect(rack_request)
+        self.class.connect(rack_request)
+      end
+
+    end
+  end
+end

data/lib/weary/client.rb

@@ -47,6 +47,7 @@ module Weary
     ]
 
     class << self
+      include Weary::Requestable
 
       REQUEST_METHODS.each do |request_method|
         # Generate a resource of the specified REQUEST_METHOD. This
@@ -116,31 +117,6 @@ module Weary
         @defaults ||= {}
       end
 
-      # An accessor to set HTTP request headers for all of the client's
-      # resources.
-      #
-      # hash - An optional Hash of key/value pairs that are sent as HTTP
-      #        request headers when a resource's request is performed.
-      #
-      # Returns a Hash of the headers.
-      def headers(hash=nil)
-        @headers = hash unless hash.nil?
-        @headers ||= {}
-      end
-
-      # Send a Rack middleware to all of the requests generated by
-      # the client.
-      #
-      # middleware - An object that implements the rack middleware interface.
-      # args       - Zero or more optional arguments to send to the middleware.
-      # block      - An optional block to send to the middleware.
-      #
-      # Returns an Array of middlewares.
-      def use(middleware, *args, &block)
-        @middlewares ||= []
-        @middlewares << [middleware, args, block]
-      end
-
       # Internal: Create and build a resource description of a request. The
       # resource is then stored in an internal hash, generating an instance
       # method.
@@ -158,10 +134,7 @@ module Weary
         resource.optional *optional
         resource.required *required
         resource.defaults defaults
-        resource.headers headers
-        if !@middlewares.nil? && !@middlewares.empty?
-          @middlewares.each {|middleware| resource.use *middleware }
-        end
+        pass_values_onto_requestable resource
         yield resource if block_given?
         self[name] = resource
       end

data/lib/weary/deferred.rb

@@ -25,7 +25,7 @@ module Weary
 
     def method_missing(method, *args, &block)
       if @model.method_defined? method
-        @target ||= @callable.call @model, @future.force
+        @target ||= @callable.call @model, @future
         @target.send(method, *args, &block)
       else
         super

data/lib/weary/env.rb

@@ -17,7 +17,7 @@ module Weary
         'SERVER_NAME'     => @request.uri.host,
         'SERVER_PORT'     => port,
         'REQUEST_URI'     => @request.uri.request_uri,
-        'HTTP_HOST'       => @request.uri.host,
+        'HTTP_HOST'       => http_host,
         'rack.url_scheme' => @request.uri.scheme,
         'rack.input'      => @request.body,
         'weary.request'   => @request
@@ -28,5 +28,10 @@ module Weary
       (@request.uri.port || @request.uri.inferred_port).to_s
     end
 
+    def http_host
+      uri = @request.uri
+      uri.host + (uri.normalized_port ? ":#{uri.normalized_port}" : "")
+    end
+
   end
 end

data/lib/weary/middleware/timeout.rb

@@ -0,0 +1,22 @@
+require 'timeout'
+
+module Weary
+  module Middleware
+    class Timeout
+
+      def initialize(app, time = 15)
+        @app = app
+        @time = time
+      end
+
+      def call(env)
+        begin
+          ::Timeout.timeout(@time) { @app.call(env) }
+        rescue ::Timeout::Error => e
+          [504, {'Content-Type' => "text/plain"}, [e.message]]
+        end
+      end
+
+    end
+  end
+end