goliath 0.9.1 → 0.9.2

data/lib/goliath/rack/builder.rb

@@ -0,0 +1,42 @@
+require 'http_router'
+
+module Goliath
+  module Rack
+    class Builder < ::Rack::Builder
+      attr_accessor :params
+      include Params::Parser
+
+      # Builds the rack middleware chain for the given API
+      #
+      # @param klass [Class] The API class to build the middlewares for
+      # @param api [Object] The instantiated API
+      # @return [Object] The Rack middleware chain
+      def self.build(klass, api)
+        Builder.app do
+          klass.middlewares.each do |mw_klass, args, blk|
+            use(mw_klass, *args, &blk)
+          end
+          if klass.maps?
+            klass.maps.each do |path, route_klass, opts, blk|
+              blk ||= Proc.new {
+                run Builder.build(route_klass, route_klass.new)
+              }
+              klass.router.add(path, opts.dup).to {|env|
+                builder = Builder.new
+                env['params'] ||= {}
+                env['params'].merge!(env['router.params']) if env['router.params']
+                builder.params = builder.retrieve_params(env)
+                builder.instance_eval(&blk)
+                builder.to_app.call(env)
+              }
+            end
+            run klass.router
+          else
+            run api
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/goliath/rack/default_response_format.rb

@@ -1,21 +1,9 @@
 module Goliath
   module Rack
     class DefaultResponseFormat
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        async_cb = env['async.callback']
-        env['async.callback'] = Proc.new do |status, headers, body|
-          async_cb.call(post_process(status, headers, body))
-        end
-
-        status, headers, body = @app.call(env)
-        post_process(status, headers, body)
-      end
+      include Goliath::Rack::AsyncMiddleware
 
-      def post_process(status, headers, body)
+      def post_process(env, status, headers, body)
         return [status, headers, body] if body.respond_to?(:to_ary)
 
         new_body = []
@@ -30,4 +18,4 @@ module Goliath
       end
     end
   end
-end
+end

data/lib/goliath/rack/formatters.rb

@@ -0,0 +1,11 @@
+module Goliath
+  module Rack
+    module Formatters
+      autoload :HTML, 'goliath/rack/formatters/html'
+      autoload :JSON, 'goliath/rack/formatters/json'
+      autoload :Plist, 'goliath/rack/formatters/plist'
+      autoload :XML, 'goliath/rack/formatters/xml'
+      autoload :YAML, 'goliath/rack/formatters/yaml'
+    end
+  end
+end

data/lib/goliath/rack/formatters/html.rb

@@ -10,25 +10,9 @@ module Goliath
       # @example
       #   use Goliath::Rack::Formatters::HTML
       class HTML
-        # Called by the framework to create the formatter.
-        #
-        # @param app The application
-        # @return [Goliath::Rack::Formatters::HTML] The HTML formatter
-        def initialize(app)
-          @app = app
-        end
-
-        def call(env)
-          async_cb = env['async.callback']
-          env['async.callback'] = Proc.new do |status, headers, body|
-            async_cb.call(post_process(status, headers, body))
-          end
-
-          status, headers, body = @app.call(env)
-          post_process(status, headers, body)
-        end
+        include Goliath::Rack::AsyncMiddleware
 
-        def post_process(status, headers, body)
+        def post_process(env, status, headers, body)
           body = [to_html(body, false)] if html_response?(headers)
           [status, headers, body]
         end

data/lib/goliath/rack/formatters/json.rb

@@ -9,24 +9,9 @@ module Goliath
       # @example
       #   use Goliath::Rack::Formatters::JSON
       class JSON
-        # Called by the framework to create the formatter.
-        #
-        # @return [Goliath::Rack::Formatters::JSON] The JSON formatter.
-        def initialize(app)
-          @app = app
-        end
-
-        def call(env)
-          async_cb = env['async.callback']
-          env['async.callback'] = Proc.new do |status, headers, body|
-            async_cb.call(post_process(status, headers, body))
-          end
-
-          status, headers, body = @app.call(env)
-          post_process(status, headers, body)
-        end
+        include AsyncMiddleware
 
-        def post_process(status, headers, body)
+        def post_process(env, status, headers, body)
           if json_response?(headers)
             body = [MultiJson.encode(body)]
           end

data/lib/goliath/rack/formatters/plist.rb

@@ -0,0 +1,32 @@
+module Goliath
+  module Rack
+    module Formatters
+      # A plist formatter. Pass in to_plist options as an option to the middleware
+      #
+      # @example
+      #   use Goliath::Rack::Formatters::PLIST, :convert_unknown_to_string => true
+      class PLIST
+        include AsyncMiddleware
+
+        def initialize(app, opts = {})
+          unless Hash.new.respond_to? :to_plist
+            fail "Please require a plist library that adds a to_plist method"
+          end
+          @app = app
+          @opts = opts
+        end
+
+        def post_process(env, status, headers, body)
+          if plist_response?(headers)
+            body = [body.to_plist(@opts)]
+          end
+          [status, headers, body]
+        end
+
+        def plist_response?(headers)
+          headers['Content-Type'] =~ %r{^application/x-plist}
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/formatters/xml.rb

@@ -9,25 +9,19 @@ module Goliath
       # @example
       #   use Goliath::Rack::Formatters::XML
       class XML
-        # Called by the framework to create the formatter.
-        #
-        # @return [Goliath::Rack::Formatters::XML] The XML formatter.
-        def initialize(app)
+        include Goliath::Rack::AsyncMiddleware
+
+        def initialize(app, opts = {})
           @app = app
+          @opts = opts
+          @opts[:root] ||= 'results'
+          @opts[:item] ||= 'item'
         end
 
-        def call(env)
-          async_cb = env['async.callback']
-          env['async.callback'] = Proc.new do |status, headers, body|
-            async_cb.call(post_process(status, headers, body))
+        def post_process(env, status, headers, body)
+          if xml_response?(headers)
+            body = [to_xml(body)]
           end
-
-          status, headers, body = @app.call(env)
-          post_process(status, headers, body)
-        end
-
-        def post_process(status, headers, body)
-          body = [to_xml(body, false)] if xml_response?(headers)
           [status, headers, body]
         end
 
@@ -35,18 +29,18 @@ module Goliath
           headers['Content-Type'] =~ %r{^application/xml}
         end
 
-        def to_xml(content, fragment=true, root='results', item='item')
+        def to_xml(content, fragment=false)
           xml_string = ''
-          xml_string += xml_header(root) unless fragment
+          xml_string << xml_header(@opts[:root]) unless fragment
 
-          xml_string += case(content.class.to_s)
-          when "Hash" then hash_to_xml(content, root, item)
-          when "Array" then array_to_xml(content, root, item)
+          xml_string << case(content.class.to_s)
+          when "Hash"   then hash_to_xml(content)
+          when "Array"  then array_to_xml(content, @opts[:item])
           when "String" then string_to_xml(content)
           else string_to_xml(content)
           end
 
-          xml_string += xml_footer(root) unless fragment
+          xml_string << xml_footer(@opts[:root]) unless fragment
           xml_string
         end
 
@@ -54,35 +48,33 @@ module Goliath
           ::Rack::Utils.escape_html(content.to_s)
         end
 
-        def hash_to_xml(content, root='results', item='item')
+        def hash_to_xml(content)
           xml_string = ''
           if content.key?('meta')
-            xml_string += xml_item('meta', content['meta'], root)
+            xml_string += xml_item('meta', content['meta'])
             content.delete('meta')
           end
 
-          content.each_pair { |key, value| xml_string += xml_item(key, value, root) }
+          content.each_pair { |key, value| xml_string << xml_item(key, value) }
           xml_string
         end
 
-        def array_to_xml(content, root='results', item='item')
+        def array_to_xml(content, item='item')
           xml_string = ''
-          content.each { |value| xml_string += xml_item(item, value, root) }
+          content.each { |value| xml_string << xml_item(item, value) }
           xml_string
         end
 
         def xml_header(root)
-          "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
-          "<#{root} xmlns:opensearch='http://a9.com/-/spec/opensearch/1.1/'\n" +
-          "         xmlns:postrank='http://www.postrank.com/xsd/2007-11-30/postrank'>\n"
+          "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<#{root}>"
         end
 
         def xml_footer(root)
           "</#{root}>"
         end
 
-        def xml_item(key, value, root)
-          "<#{key}>#{to_xml(value, true, root)}</#{key}>\n"
+        def xml_item(key, value)
+          "<#{key}>#{to_xml(value, true)}</#{key}>\n"
         end
       end
     end

data/lib/goliath/rack/formatters/yaml.rb

@@ -0,0 +1,27 @@
+require 'yaml'
+
+module Goliath
+  module Rack
+    module Formatters
+      # A YAML formatter.
+      #
+      # @example
+      #   use Goliath::Rack::Formatters::YAML
+      class YAML
+        include Goliath::Rack::AsyncMiddleware
+
+        def post_process(env, status, headers, body)
+          if yaml_response?(headers)
+            body = [body.to_yaml]
+          end
+          [status, headers, body]
+        end
+
+        def yaml_response?(headers)
+          headers['Content-Type'] =~ %r{^text/yaml}
+        end
+      end
+    end
+  end
+end
+

data/lib/goliath/rack/jsonp.rb

@@ -6,19 +6,7 @@ module Goliath
     #  use Goliath::Rack::JSONP
     #
     class JSONP
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        async_cb = env['async.callback']
-
-        env['async.callback'] = Proc.new do |status, headers, body|
-          async_cb.call(post_process(env, status, headers, body))
-        end
-        status, headers, body = @app.call(env)
-        post_process(env, status, headers, body)
-      end
+      include Goliath::Rack::AsyncMiddleware
 
       def post_process(env, status, headers, body)
         return [status, headers, body] unless env.params['callback']

data/lib/goliath/rack/params.rb

@@ -14,40 +14,68 @@ module Goliath
     #  use Goliath::Rack::Params
     #
     class Params
-      def initialize(app)
-        @app = app
-      end
+      module Parser
+        def retrieve_params(env)
+          params = env['params'] || {}
+          params.merge!(::Rack::Utils.parse_nested_query(env['QUERY_STRING']))
 
-      def call(env)
-        env['params'] = retrieve_params(env)
-        @app.call(env)
-      end
+          if env['rack.input']
+            post_params = ::Rack::Utils::Multipart.parse_multipart(env)
+            unless post_params
+              body = env['rack.input'].read
+              env['rack.input'].rewind
 
-      def retrieve_params(env)
-        params = {}
-        params.merge!(::Rack::Utils.parse_nested_query(env['QUERY_STRING']))
-
-        if env['rack.input']
-          post_params = ::Rack::Utils::Multipart.parse_multipart(env)
-          unless post_params
-            body = env['rack.input'].read
-            env['rack.input'].rewind
-
-            post_params = case(env['CONTENT_TYPE'])
-            when URL_ENCODED then
-              ::Rack::Utils.parse_nested_query(body)
-            when JSON_ENCODED then
-              MultiJson.decode(body)
-            else
-              {}
+              unless body.empty?
+                begin
+                  post_params = case(env['CONTENT_TYPE'])
+                  when URL_ENCODED then
+                    ::Rack::Utils.parse_nested_query(body)
+                  when JSON_ENCODED then
+                    MultiJson.decode(body)
+                  else
+                    {}
+                  end
+                rescue StandardError => e
+                  raise Goliath::Validation::BadRequestError, "Invalid parameters: #{e.class.to_s}"
+                end
+              else
+                post_params = {}
+              end
             end
+
+            params.merge!(post_params)
           end
 
-          params.merge!(post_params)
+          indifferent_params(params)
         end
 
-        params
+        def indifferent_params(params)
+          params = indifferent_hash.merge(params)
+          params.each do |key, value|
+            next unless value.is_a?(Hash)
+            params[key] = indifferent_params(value)
+          end
+        end
+
+        # Creates a Hash with indifferent access.
+        def indifferent_hash
+          Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+        end
+      end
+
+      include Goliath::Rack::Validator
+      include Parser
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Goliath::Rack::Validator.safely(env) do
+          env['params'] = retrieve_params(env)
+          @app.call(env)
+        end
       end
     end
   end
-end
+end

data/lib/goliath/rack/render.rb

@@ -11,23 +11,13 @@ module Goliath
     #
     class Render
       include ::Rack::RespondTo
+      include Goliath::Rack::AsyncMiddleware
 
       def initialize(app, types = nil)
         @app = app
         ::Rack::RespondTo.media_types = [types].flatten if types
       end
 
-      def call(env)
-        async_cb = env['async.callback']
-
-        env['async.callback'] = Proc.new do |status, headers, body|
-          async_cb.call(post_process(env, status, headers, body))
-        end
-
-        status, headers, body = @app.call(env)
-        post_process(env, status, headers, body)
-      end
-
       def post_process(env, status, headers, body)
         ::Rack::RespondTo.env = env
 
@@ -35,11 +25,9 @@ module Goliath
         # setting of selected_media_type, so it's required
 
         respond_to do |format|
-          format.json { body }
-          format.html { body }
-          format.xml { body }
-          format.rss { body }
-          format.js { body }
+          ::Rack::RespondTo.media_types.each do |type|
+            format.send(type, Proc.new { body })
+          end
         end
 
         extra = { 'Content-Type' => get_content_type(env),
@@ -50,14 +38,17 @@ module Goliath
       end
 
       def get_content_type(env)
-        fmt = env.params['format']
-        fmt = fmt.last if fmt.is_a?(Array)
+        type = if env.respond_to? :params
+          fmt = env.params['format']
+          fmt = fmt.last if fmt.is_a?(Array)
 
-        type = if fmt.nil? || fmt =~ /^\s*$/
-          ::Rack::RespondTo.selected_media_type
-        else
-          ::Rack::RespondTo::MediaType(fmt)
+          if !fmt.nil? && fmt !~ /^\s*$/
+            ::Rack::RespondTo::MediaType(fmt)
+          end
         end
+        
+        type = ::Rack::RespondTo.env['HTTP_ACCEPT'] if type.nil?
+        type = ::Rack::RespondTo.selected_media_type if type == '*/*'
 
         "#{type}; charset=utf-8"
       end