weary 0.7.2 → 1.0.0.rc1

data/lib/weary/response.rb

@@ -1,110 +1,59 @@
+require 'rack/response'
+
+autoload :MultiJson, 'multi_json'
+
 module Weary
   class Response
-  
-    attr_reader :raw, :requester, :code, :message, :header, :content_type, :cookie, :body, :url
-    
-    def initialize(http_response, requester)
-      @raw = http_response
-      @requester = requester
-      @url = requester.uri
-      @code = http_response.code.to_i
-      @message = http_response.message
-      @header = http_response.to_hash
-      @content_type = http_response.content_type
-      @cookie = http_response['Set-Cookie']
-      @body = http_response.body
+    include Rack::Response::Helpers
+
+    def initialize(body, status, headers)
+      @response = Rack::Response.new body, status, headers
+      @status = self.status
+    end
+
+    def status
+      @response.status.to_i
+    end
+
+    def header
+      @response.header
+    end
+    alias headers header
+
+    def body
+      buffer = ""
+      @response.body.each {|chunk| buffer << chunk }
+      buffer
+    end
+
+    def each(&iterator)
+      @response.body.each(&iterator)
+    end
+
+    def finish
+      [status, header, self]
+    end
+
+    def success?
+      @response.successful?
     end
-    
-    # Is this an HTTP redirect?
+
     def redirected?
-      raw.is_a? Net::HTTPRedirection
-    end
-    
-    # Was this Request successful?
-    def success?
-      (200..299).include?(code)
+      @response.redirection?
     end
-    
-    # Returns a symbol corresponding to the Response's Content Type
-    def format
-      @format ||= case content_type
-        when *ContentTypes[:json]
-          :json
-        when *ContentTypes[:xml]
-          :xml
-        when *ContentTypes[:html]
-          :html
-        when *ContentTypes[:yaml]
-          :yaml
-        else
-          :plain
-      end
+
+    def length
+      @response.length
     end
-    
-    # Follow the Redirect
-    def follow_redirect
-      if redirected?
-        new_request = requester.dup
-        new_request.uri = @raw['location']
-        new_request.perform
-      end  
+
+    def call(env)
+      self.finish
     end
-    
-    # Parse the body with Crack parsers (if XML/HTML) or Yaml parser
+
     def parse
-      raise StandardError, "The Response has no body. #{requester.via.to_s.upcase} request sent." unless body
-      handle_errors
-      case format
-        when :xml, :html
-          Crack::XML.parse body
-        when :json
-          Crack::JSON.parse body
-        when :yaml
-          YAML::load body
-        else
-          body
-      end
-    end
-    
-    # Puts the body
-    def to_s
-      body.to_s
-    end
-    
-    # Same as parse[key]
-    def [](key)
-      parse[key]
+      raise "The response does not contain a body" if body.nil? || body.empty?
+      raise "Unable to parse Content-Type: #{content_type}" unless content_type =~ /json($|;.*)/
+      MultiJson.decode body
     end
-    
-    private
-      def handle_errors
-        case @code
-          when 301,302
-            raise RedirectionError, "#{@message} to #{@raw['location']}"
-          when 200...400
-            return
-          when 400
-            raise BadRequest, "Failed with #{@code}: #{@message}"
-          when 401
-            raise Unauthorized, "Failed with #{@code}: #{@message}"
-          when 403
-            raise Forbidden, "Failed with #{@code}: #{@message}"
-          when 404
-            raise NotFound, "Failed with #{@code}: #{@message}"
-          when 405
-            raise MethodNotAllowed, "Failed with #{@code}: #{@message}"
-          when 409
-            raise ResourceConflict, "Failed with #{@code}: #{@message}"
-          when 422
-            raise UnprocessableEntity, "Failed with #{@code}: #{@message}"
-          when 401...500
-            raise ClientError, "Failed with #{@code}: #{@message}"
-          when 500...600
-            raise ServerError, "Failed with #{@code}: #{@message}"
-          else
-            raise HTTPError, "Unknown response code: #{@code}"
-        end
-      end
-          
   end
 end

data/lib/weary/route.rb

@@ -0,0 +1,53 @@
+require 'rack'
+
+module Weary
+  class Route
+    NotFoundError = Class.new(StandardError)
+    NotAllowedError = Class.new(StandardError)
+
+    def initialize(resources, domain="")
+      @resources = resources
+      @domain = domain
+    end
+
+    def call(env)
+      begin
+        request = Rack::Request.new(env)
+        resource = route(request)
+        url_variables = resource.url.extract("#{@domain}#{request.path}")
+        resource.request(url_variables.merge(request.params)).call(env)
+      rescue NotFoundError => e
+        [404, {'Content-Type' => "text/plain"}, [e.message]]
+      rescue NotAllowedError => e
+        [405, {'Content-Type' => "text/plain"}, [e.message]]
+      rescue Weary::Resource::UnmetRequirementsError => e
+        [403, {'Content-Type' => "text/plain"}, [e.message]]
+      rescue Exception => e
+        [500, {'Content-Type' => "text/plain"}, [e.message]]
+      end
+    end
+
+    def route(request)
+      subset = select_by_url("#{@domain}#{request.path}")
+      raise NotFoundError, "Not Found" if subset.empty?
+      subset = select_by_method(request.request_method, subset)
+      raise NotAllowedError, "Method Not Allowed" if subset.empty?
+      subset.first
+    end
+
+    private
+
+    def select_by_url(url, set=@resources)
+      set.select do |resource|
+        !resource.url.extract(url).nil?
+      end
+    end
+
+    def select_by_method(method, set=@resources)
+      set.select do |resource|
+        resource.method.to_s.upcase == method
+      end
+    end
+
+  end
+end

data/lib/weary/version.rb

@@ -0,0 +1,3 @@
+module Weary
+  VERSION = "1.0.0.rc1"
+end

data/spec/spec_helper.rb

@@ -1,58 +1,6 @@
-begin
-  # Try to require the preresolved locked set of gems.
-  require File.expand_path('../.bundle/environment', __FILE__)
-rescue LoadError
-  # Fall back on doing an unlocked resolve at runtime.
-  require "rubygems"
-  require "bundler"
-  Bundler.setup
-end
+require 'weary'
+require 'webmock/rspec'
 
-begin
-  require 'weary'
-rescue LoadError
-  lib_path = File.join(File.dirname(__FILE__), '..', 'lib')
-  $LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
-  require 'weary'
-end
+Dir['./spec/support/**/*.rb'].each {|f| require f }
 
-require 'spec'
-require 'fakeweb'
-
-def get_fixture(filename)
-  open(File.join(File.dirname(__FILE__), 'fixtures', "#{filename.to_s}")).read
-end
-
-def http_status_message(code)
-  message = case code.to_i
-    when 200
-      "OK"
-    when 301
-      "Moved Permanently"
-    when 302
-      "Moved Temporarily"
-    when 400
-      "Bad Request"
-    when 401
-      "Unauthorized"
-    when 403
-      "Forbidden"
-    when 404
-      "Not Found"
-    when 405
-      "Method Not Allowed"
-    when 409
-      "Conflict"
-    when 418
-      "I'm a teapot"  
-    when 422
-      "Unprocessable Entity"
-    when 401...500
-      "Client Error"
-    when 500...600
-      "Server Error"
-    else
-      "Unknown"
-  end
-  [code.to_s,message]
-end
+WebMock.disable_net_connect!

data/spec/support/shared_examples_for_a_rack_app.rb

@@ -0,0 +1,70 @@
+shared_examples_for "a Rack application" do
+  it { should respond_to :call }
+
+  it "takes one argument, the environment" do
+    method = if subject.is_a? Module
+      subject.method :call
+    else
+      subject.class.instance_method :call
+    end
+    method.arity.should eq 1
+  end
+
+  it "returns an Array" do
+    subject.call(env).should be_an Array
+  end
+
+  it "returns with three arguments" do
+    subject.call(env).length.should be 3
+  end
+
+  describe "the status" do
+    let(:status) { subject.call(env).first }
+
+    it "is greater than or equal to 100 when parsed as an integer" do
+      status.to_i.should be >= 100
+    end
+  end
+
+  describe "the headers" do
+    let(:headers) { subject.call(env)[1] }
+
+    it { headers.should respond_to :each }
+
+    it "yields values of key and value" do
+      headers.should be_all {|key, value| !key.nil? && !value.nil? }
+    end
+
+    it "contains keys of Strings" do
+      headers.keys.should be_all {|key| key.kind_of? String }
+    end
+
+    it "does not contain a 'Status' key" do
+      headers.keys.map(&:downcase).should_not include 'status'
+    end
+
+    it "contains values of Strings" do
+      headers.values.should be_all {|value| value.kind_of? String }
+    end
+
+    it "contains a 'Content-Type' header" do
+      headers.should have_key 'Content-Type'
+    end
+  end
+
+  describe "the body" do
+    let(:body) { subject.call(env).last }
+
+    it { body.should respond_to :each }
+
+    it "yields only String values" do
+      map = []
+      body.each {|string| map << string }
+      # We do this strange mapping, since the only requirement
+      # of the body is it responds to :each.
+      # This allows us to use Array predicates
+      map.should be_all {|i| i.kind_of? String }
+    end
+  end
+
+end

data/spec/support/shared_examples_for_a_rack_env.rb

@@ -0,0 +1,14 @@
+shared_examples_for "a Rack env" do
+  # From the Rack spec:
+  # http://rack.rubyforge.org/doc/SPEC.html
+  it { should be_an_instance_of Hash }
+  it { should have_key "REQUEST_METHOD"}
+  it "does not have an empty value for REQUEST_METHOD" do
+    subject["REQUEST_METHOD"].should_not be_empty
+  end
+  it { should have_key "SCRIPT_NAME"}
+  it { should have_key "PATH_INFO"}
+  it { should have_key "QUERY_STRING"}
+  it { should have_key "SERVER_NAME"}
+  it { should have_key "SERVER_PORT"}
+end

data/spec/support/shared_examples_for_a_uri.rb

@@ -0,0 +1,9 @@
+shared_examples_for "a URI" do
+  it { uri.should respond_to(:path) }
+  it { uri.should respond_to(:query) }
+  it { uri.should respond_to(:host) }
+  it { uri.should respond_to(:port) }
+  it { uri.should respond_to(:inferred_port) }
+  it { uri.should respond_to(:request_uri) }
+  it { uri.should respond_to(:scheme) }
+end

data/spec/weary/adapter_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Weary::Adapter do
+  subject { Class.new { include Weary::Adapter }.new }
+  let(:env) {
+    {
+      "REQUEST_METHOD"=>"GET",
+      "SCRIPT_NAME"=>"",
+      "PATH_INFO"=>"/api/v2/json/repos/show/mwunsch/weary",
+      "QUERY_STRING"=>nil,
+      "SERVER_NAME"=>"github.com",
+      "SERVER_PORT"=>80,
+      "REQUEST_URI"=>"/api/v2/json/repos/show/mwunsch/weary"
+    }
+  }
+
+  describe "#call" do
+    it_behaves_like "a Rack application"
+  end
+
+  describe "connect" do
+    it "returns a Rack::Response" do
+      subject.connect(Rack::Request.new(env)).should be_a Rack::Response
+    end
+  end
+end

data/spec/weary/adapters/nethttp_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Weary::Adapter::NetHttp do
+  before do
+    @url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    @request = Weary::Request.new @url
+  end
+
+  describe ".call" do
+    before do
+      stub_request(:get, @url).
+         to_return(:status => 200, :body => "", :headers => {})
+    end
+
+    it_behaves_like "a Rack application" do
+      subject { described_class }
+      let(:env) { @request.env }
+    end
+
+    it "performs the request through the connect method" do
+      described_class.stub(:connect) { Rack::Response.new("", 200, {})}
+      described_class.should_receive :connect
+      described_class.call(@request.env)
+    end
+  end
+
+  describe "#call" do
+    it "calls the class method `.call`" do
+      described_class.stub(:call) { [200, {'Content-Type' => 'text/plain'}, [""]] }
+      described_class.should_receive(:call)
+      described_class.new.call(@request.env)
+    end
+  end
+
+  describe ".connect" do
+    before do
+      stub_request(:get, @url)
+    end
+
+    it "performs the http request" do
+      req = Rack::Request.new(@request.env)
+      described_class.connect(req)
+      a_request(:get, @url).should have_been_made
+    end
+
+    it "returns a Rack::Response" do
+      req = Rack::Request.new(@request.env)
+      described_class.connect(req).should be_kind_of Rack::Response
+    end
+
+    it "sets appropriate request headers" do
+      @request.headers 'User-Agent' => Weary::USER_AGENTS['Lynx 2.8.4rel.1 on Linux']
+      req = Rack::Request.new(@request.env)
+      described_class.connect(req)
+      a_request(:get, @url).with(:headers => @request.headers).should have_been_made
+    end
+
+    it "sets the body of the request" do
+      stub_request(:post, @url)
+      @request.method = "POST"
+      @request.params :foo => "baz"
+      req = Rack::Request.new(@request.env)
+      described_class.connect(req)
+      a_request(:post, @url).with(:body => "foo=baz").should have_been_made
+    end
+  end
+
+  describe ".normalize_request_headers" do
+    it "removes the HTTP_ prefix from request headers" do
+      @request.headers 'User-Agent' => Weary::USER_AGENTS['Lynx 2.8.4rel.1 on Linux']
+      headers = described_class.normalize_request_headers(@request.env)
+      headers.should have_key "User-Agent"
+    end
+  end
+
+  describe ".socket" do
+    it "sets up the http connection" do
+      req = Rack::Request.new(@request.env)
+      described_class.socket(req).should be_kind_of Net::HTTP
+    end
+  end
+
+  describe ".request_class" do
+    it "gets the Net::HTTP request class for the request method" do
+      described_class.request_class("POST").should be Net::HTTP::Post
+    end
+  end
+end