restfulness 0.3.2 → 0.3.3

data/lib/restfulness/headers/media_type.rb

@@ -0,0 +1,127 @@
+module Restfulness
+  module Headers
+
+    # Generic media type handling according to the RFC2616 HTTP/1.1 header fields
+    # specification.
+    #
+    # If instantiated with a string, the MediaType object will attempt to parse and
+    # set the objects attributes.
+    #
+    # If an empty or no string is provided, the media-type can be prepared by setting
+    # the type, subtype and optional parameters values. Calling the #to_s method will
+    # provide the compiled version.
+    #
+    # Accessor names and parsing is based on details from https://en.wikipedia.org/wiki/Media_type.
+    #
+    class MediaType
+
+      # First part of the mime-type, typically "application", "text", or similar.
+      # Vendor types are not supported.
+      attr_accessor :type
+
+      # Always last part of definition. For example:
+      #
+      #  * "json" from "application/json"
+      #  * "user" from "application/vnd.example.user+json;version=1"
+      #
+      attr_accessor :subtype
+
+      # Refers to the vendor part of type string, for example:
+      #
+      #  * "example" from "application/vnd.example.user+json"
+      #
+      attr_accessor :vendor
+
+      # When using vendor content types, a suffix may be provided:
+      #
+      #  * "json" from "application/vnd.example.user+json"
+      #
+      attr_accessor :suffix
+
+      # Hash of parameters using symbols as keys
+      attr_accessor :parameters
+
+      def initialize(str = "")
+        # Defaults
+        self.type = "*"
+        self.subtype = "*"
+        self.vendor = ""
+        self.suffix = ""
+        self.parameters = {}
+
+        # Attempt to parse string if provided
+        parse(str) unless str.empty?
+      end
+
+      def parse(str)
+        # Split between base and parameters
+        parts = str.split(';').map{|p| p.strip}
+        t = parts.shift.split('/', 2)
+        self.type = t[0] if t[0]
+
+        # Handle subtype, and more complex vendor + suffix
+        if t[1]
+          (v, s) = t[1].split('+',2)
+          self.suffix = s if s
+          s = v.split('.')
+          s.shift if s[0] == 'vnd'
+          self.subtype = s.pop
+          self.vendor = s.join('.') unless s.empty?
+        end
+
+        # Finally, with remaining parts, handle parameters
+        self.parameters = Hash[parts.map{|p| (k,v) = p.split('=', 2); [k.to_sym, v]}]
+      end
+
+      def to_s
+        base = "#{type}/"
+        if !vendor.empty?
+          base << ["vnd", vendor, subtype].join('.')
+        else
+          base << subtype 
+        end
+        base << "+#{suffix}" unless suffix.empty?
+        base << ";" + parameters.map{|k,v| "#{k}=#{v}"}.join(';') unless parameters.empty?
+        base
+      end
+
+      def ==(value)
+        if value.is_a?(String)
+          value = self.class.new(value)
+        end
+        raise "Invalid type comparison!" unless value.is_a?(MediaType)
+        type == value.type &&
+          subtype == value.subtype &&
+          vendor == value.vendor &&
+          suffix == value.suffix &&
+          parameters == value.parameters
+      end
+
+      def charset
+        parameters[:charset]
+      end
+
+      def version
+        parameters[:version]
+      end
+
+      def json?
+        type == "application" && (subtype == "json" || suffix == "json")
+      end
+
+      def xml?
+        type == "application" && (subtype == "xml" || suffix == "xml")
+      end
+
+      def text?
+        type == "text" && subtype == "plain"
+      end
+
+      def form?
+        type == "application" && subtype == "x-www-form-urlencoded"
+      end
+
+    end
+
+  end
+end

data/lib/restfulness/request.rb

@@ -1,12 +1,15 @@
 module Restfulness
 
   # Simple, indpendent, request interface for dealing with the incoming information
-  # in a request. 
+  # in a request.
   #
   # Currently wraps around the information provided in a Rack Request object.
   class Request
     include Requests::Authorization
 
+    # Expose rack env to interact with rack middleware
+    attr_accessor :env
+
     # Who does this request belong to?
     attr_reader :app
 
@@ -55,19 +58,32 @@ module Restfulness
       @sanitized_query ||= uri.query ? Sanitizer.sanitize_query_string(uri.query) : ''
     end
 
+    def accept
+      if headers[:accept]
+        @accept ||= Headers::Accept.new(headers[:accept])
+      end
+    end
+
+    def content_type
+      if headers[:content_type]
+        @content_type ||= Headers::MediaType.new(headers[:content_type])
+      end
+    end
+
     def params
       @params ||= begin
-        if body.nil? || body.length == 0
-          {}
-        else
-          case headers[:content_type]
-          when /application\/json/
-            @params = params_from_json(body)
-          when /application\/x\-www\-form\-urlencoded/
-            @params = params_from_form(body)
+        data = body_to_string || ""
+        if data.length > 0
+          if content_type && content_type.json?
+            params_from_json(data)
+          elsif content_type && content_type.form?
+            params_from_form(data)
           else
+            # Body provided with no or invalid content type
             raise HTTPException.new(406)
           end
+        else
+          {}
         end
       end
     end
@@ -90,15 +106,27 @@ module Restfulness
 
     protected
 
-    def params_from_json(body)
-      MultiJson.decode(body)
+    def body_to_string
+      unless body.nil?
+        # Sometimes the body can be a StringIO, Tempfile, or some other freakish IO.
+        if body.respond_to?(:read)
+          body.read
+        else
+          body
+        end
+      else
+        ""
+      end
+    end
+
+    def params_from_json(data)
+      MultiJson.decode(data)
     rescue MultiJson::LoadError
-      raise HTTPException.new(400)
+      raise HTTPException.new(400, "Invalid JSON in request body")
     end
 
-    def params_from_form(body)
-      # Sometimes the body can be a StringIO
-      Rack::Utils.parse_query(body.is_a?(StringIO) ? body.read : body)
+    def params_from_form(data)
+      Rack::Utils.parse_query(data)
     end
 
   end

data/lib/restfulness/version.rb

@@ -1,3 +1,3 @@
 module Restfulness
-  VERSION = "0.3.2"
+  VERSION = "0.3.3"
 end

data/restfulness.gemspec

@@ -25,5 +25,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 2.14.1"
+  spec.add_development_dependency "rspec"
 end

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ require 'bundler/setup'
 require 'restfulness' # and any other gems you need
 
 RSpec.configure do |config|
-  config.color_enabled = true
+  config.color = true
 
   # Avoid deprication messages with this:
   I18n.config.enforce_available_locales = false

data/spec/unit/application_spec.rb

@@ -14,7 +14,7 @@ describe Restfulness::Application do
   describe "#router" do
     it "should access class's router" do
       obj = klass.new
-      obj.router.should eql(klass.router)
+      expect(obj.router).to eql(klass.router)
     end
   end
 
@@ -23,8 +23,8 @@ describe Restfulness::Application do
       env = {}
       obj = klass.new
       app = double(:app)
-      app.should_receive(:call).with(env)
-      obj.should_receive(:build_rack_app).and_return(app)
+      expect(app).to receive(:call).with(env)
+      expect(obj).to receive(:build_rack_app).and_return(app)
       obj.call(env)
     end
   end
@@ -34,10 +34,10 @@ describe Restfulness::Application do
       obj = klass.new
       obj.class.middlewares << Rack::ShowExceptions
       app = obj.send(:build_rack_app)
-      app.should be_a(Rack::Builder)
+      expect(app).to be_a(Rack::Builder)
       # Note, this might brake if Rack changes!
-      app.instance_variable_get(:@use).first.call.should be_a(klass.middlewares.first)
-      app.instance_variable_get(:@run).should be_a(Restfulness::Dispatchers::Rack)
+      expect(app.instance_variable_get(:@use).first.call).to be_a(klass.middlewares.first)
+      expect(app.instance_variable_get(:@run)).to be_a(Restfulness::Dispatchers::Rack)
     end
   end
 
@@ -45,18 +45,18 @@ describe Restfulness::Application do
 
     context "basic usage" do
       it "should build a new router with block" do
-        klass.router.should_not be_nil
-        klass.router.should be_a(Restfulness::Router)
+        expect(klass.router).not_to be_nil
+        expect(klass.router).to be_a(Restfulness::Router)
       end
 
       it "should be accessable from instance" do
         obj = klass.new
-        obj.router.should eql(klass.router)
+        expect(obj.router).to eql(klass.router)
       end
 
       it "should pass block to Router instance" do
         block = lambda { }
-        Restfulness::Router.should_receive(:new).with(&block)
+        expect(Restfulness::Router).to receive(:new).with(no_args, &block)
         Class.new(Restfulness::Application) do
           routes &block
         end
@@ -67,14 +67,14 @@ describe Restfulness::Application do
 
   describe ".middlewares" do
     it "should provide empty array of middlewares" do
-      klass.middlewares.should be_a(Array)
-      klass.middlewares.should be_empty
+      expect(klass.middlewares).to be_a(Array)
+      expect(klass.middlewares).to be_empty
     end
   end
 
   describe ".logger" do
     it "should return main logger" do
-      klass.logger.should eql(Restfulness.logger)
+      expect(klass.logger).to eql(Restfulness.logger)
     end
   end
 
@@ -83,7 +83,7 @@ describe Restfulness::Application do
       orig = Restfulness.logger
       logger = double(:Logger)
       klass.logger = logger
-      Restfulness.logger.should eql(logger)
+      expect(Restfulness.logger).to eql(logger)
       Restfulness.logger = orig
     end
   end

data/spec/unit/dispatcher_spec.rb

@@ -6,7 +6,7 @@ describe Restfulness::Dispatcher do
   describe "#initialize" do
     it "should assign app variable" do
       obj = Restfulness::Dispatcher.new(:foo)
-      obj.app.should eql(:foo)
+      expect(obj.app).to eql(:foo)
     end
   end
 

data/spec/unit/dispatchers/rack_spec.rb

@@ -16,7 +16,7 @@ describe Restfulness::Dispatchers::Rack do
   let :app do
     Class.new(Restfulness::Application) {
       routes do
-        add 'projects', RackExampleResource 
+        add 'projects', RackExampleResource
       end
     }.new
   end
@@ -46,9 +46,9 @@ describe Restfulness::Dispatchers::Rack do
 
     it "should handle basic call and return response" do
       res = obj.call(env)
-      res[0].should eql(200)
-      res[1].should be_a(Hash)
-      res[2].first.should eql('rack_example_result')
+      expect(res[0]).to eql(200)
+      expect(res[1]).to be_a(Hash)
+      expect(res[2].first).to eql('rack_example_result')
     end
 
 
@@ -60,7 +60,7 @@ describe Restfulness::Dispatchers::Rack do
       actions = ['DELETE', 'GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'OPTIONS']
       actions.each do |action|
         val = obj.send(:parse_action, env, action)
-        val.should eql(action.downcase.to_sym)
+        expect(val).to eql(action.downcase.to_sym)
       end
     end
 
@@ -72,12 +72,12 @@ describe Restfulness::Dispatchers::Rack do
 
     it "should override the action if the override header is present" do
       env['HTTP_X_HTTP_METHOD_OVERRIDE'] = 'PATCH'
-      obj.send(:parse_action, env, 'POST').should eql(:patch)
+      expect(obj.send(:parse_action, env, 'POST')).to eql(:patch)
     end
 
     it "should handle junk in action override header" do
       env['HTTP_X_HTTP_METHOD_OVERRIDE'] = ' PatCH '
-      obj.send(:parse_action, env, 'POST').should eql(:patch)
+      expect(obj.send(:parse_action, env, 'POST')).to eql(:patch)
     end
 
   end
@@ -86,8 +86,8 @@ describe Restfulness::Dispatchers::Rack do
 
     it "should parse headers from environment" do
       res = obj.send(:prepare_headers, env)
-      res[:content_type].should eql('application/json')
-      res[:x_auth_token].should eql('foobartoken')
+      expect(res[:content_type]).to eql('application/json')
+      expect(res[:x_auth_token]).to eql('foobartoken')
     end
   end
 
@@ -96,24 +96,25 @@ describe Restfulness::Dispatchers::Rack do
     it "should prepare request object with main fields" do
       req = obj.send(:prepare_request, env)
 
-      req.uri.should be_a(URI)
-      req.action.should eql(:get)
-      req.body.should be_nil
-      req.headers.keys.should include(:x_auth_token)
-      req.remote_ip.should eql('192.168.1.23')
-      req.user_agent.should eql('Some Navigator')
+      expect(req.uri).to be_a(URI)
+      expect(req.action).to eql(:get)
+      expect(req.body).to be_nil
+      expect(req.headers.keys).to include(:x_auth_token)
+      expect(req.remote_ip).to eql('192.168.1.23')
+      expect(req.user_agent).to eql('Some Navigator')
+      expect(req.env).to be env
 
-      req.query.should_not be_empty
-      req.query[:query].should eql('test')
+      expect(req.query).not_to be_empty
+      expect(req.query[:query]).to eql('test')
 
-      req.headers[:content_type].should eql('application/json')
+      expect(req.headers[:content_type]).to eql('application/json')
     end
 
     it "should handle the body stringio" do
       env['rack.input'] = StringIO.new("Some String")
 
       req = obj.send(:prepare_request, env)
-      req.body.read.should eql('Some String')
+      expect(req.body.read).to eql('Some String')
     end
 
     it "should rewind the body stringio" do
@@ -121,7 +122,7 @@ describe Restfulness::Dispatchers::Rack do
       env['rack.input'].read
 
       req = obj.send(:prepare_request, env)
-      req.body.read.should eql('Some String')
+      expect(req.body.read).to eql('Some String')
     end
 
 

data/spec/unit/exceptions_spec.rb

@@ -5,15 +5,15 @@ describe Restfulness::HTTPException do
   describe "#initialize" do
     it "should assign variables" do
       obj = Restfulness::HTTPException.new(200, "payload", :message => 'foo', :headers => {})
-      obj.status.should eql(200)
-      obj.payload.should eql("payload")
-      obj.message.should eql('foo')
-      obj.headers.should eql({})
+      expect(obj.status).to eql(200)
+      expect(obj.payload).to eql("payload")
+      expect(obj.message).to eql('foo')
+      expect(obj.headers).to eql({})
     end
 
     it "should use status status for message if none provided" do
       obj = Restfulness::HTTPException.new(200, "payload")
-      obj.message.should eql('OK')
+      expect(obj.message).to eql('OK')
     end
   end