goliath 0.9.4 → 1.0.0.beta.1

data/lib/goliath/rack/builder.rb

@@ -1,22 +1,9 @@
-require 'http_router'
-
-class HttpRouter::Route
-  attr_accessor :api_class
-end
-
 module Goliath
   module Rack
     class Builder < ::Rack::Builder
       attr_accessor :params
-      attr_reader :inner_app
       include Params::Parser
 
-      alias_method :original_run, :run
-      def run(app)
-        @inner_app = app
-        original_run(app)
-      end
-
       # Builds the rack middleware chain for the given API
       #
       # @param klass [Class] The API class to build the middlewares for
@@ -27,30 +14,7 @@ module Goliath
           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|
-              route = klass.router.add(path, opts.dup)
-              route.api_class = route_klass
-              route.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) if blk
-                route_klass.middlewares.each do |mw|
-                  builder.instance_eval { use mw[0], *mw[1], &mw[2] }
-                end if route_klass
-                if route_klass or blk.nil?
-                  raise "You cannot use `run' and supply a routing class at the same time" if builder.inner_app
-                  builder.instance_eval { run env.event_handler }
-                end
-                builder.to_app.call(env)
-              }
-            end
-            run klass.router
-          else
-            run api
-          end
+          run api
         end
       end
     end

data/lib/goliath/rack/favicon.rb

@@ -0,0 +1,31 @@
+require 'time'
+
+# Reads a favicon.ico statically at load time, renders it on any request for
+# '/favicon.ico', and sends every other request on downstream.
+#
+# Rack::Static is a better option if you're serving several static assets.
+#
+module Goliath
+  module Rack
+    class Favicon
+      def initialize(app, filename)
+        @app = app
+        @favicon = File.read(File.join(filename))
+        @expires  = Time.at(Time.now + (60 * 60 * 24 * 7)).utc.rfc822.to_s
+        @last_modified = File.mtime(filename).utc.rfc822.to_s
+      end
+
+      def call(env)
+        if env['REQUEST_PATH'] == '/favicon.ico'
+          env.logger.info('Serving favicon.ico')
+
+          [200, {'Last-Modified' => @last_modified,
+                 'Expires' => @expires,
+                 'Content-Type' => "image/vnd.microsoft.icon"}, @favicon]
+        else
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module Goliath
 
         def post_process(env, status, headers, body)
           if json_response?(headers)
-            body = [MultiJson.encode(body)]
+            body = [MultiJson.dump(body)]
           end
           [status, headers, body]
         end

data/lib/goliath/rack/heartbeat.rb

@@ -16,6 +16,7 @@ module Goliath
 
       def call(env)
         if env['PATH_INFO'] == @opts[:path]
+          env[Goliath::Constants::RACK_LOGGER] = Log4r::Logger.root unless @opts[:log]
           @opts[:response]
         else
           @app.call(env)

data/lib/goliath/rack/jsonp.rb

@@ -18,6 +18,7 @@ module Goliath
           response = body
         end
 
+        headers[Goliath::Constants::CONTENT_TYPE] = 'application/javascript'
         [status, headers, ["#{env.params['callback']}(#{response})"]]
       end
     end

data/lib/goliath/rack/params.rb

@@ -31,7 +31,7 @@ module Goliath
                   when URL_ENCODED then
                     ::Rack::Utils.parse_nested_query(body)
                   when JSON_ENCODED then
-                    MultiJson.decode(body)
+                    MultiJson.load(body)
                   else
                     {}
                   end
@@ -42,24 +42,9 @@ module Goliath
                 post_params = {}
               end
             end
-
             params.merge!(post_params)
           end
-
-          indifferent_params(params)
-        end
-
-        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 }
+          params
         end
       end
 

data/lib/goliath/rack/render.rb

@@ -31,7 +31,6 @@ module Goliath
         end
 
         extra = { 'Content-Type' => get_content_type(env),
-                  'Server' => 'PostRank Goliath API Server',
                   'Vary' => [headers.delete('Vary'), 'Accept'].compact.join(',') }
 
         [status, extra.merge(headers), body]

data/lib/goliath/rack/templates.rb

@@ -321,14 +321,25 @@ module Goliath
           Tilt.new(layout_filename, nil, options)
         end
 
-        template_filename = find_template(views, data, engine)
-        unless template_filename
-          raise Goliath::Validation::InternalServerError, "Template #{data} not found in #{views} for #{engine}"
-        end
+        # mimic sinatra behavior, if a string is given consider it as a template source
+        # otherwise a symbol is expected to be a template path
+        if data.is_a?(Symbol)
+          template_filename = find_template(views, data, engine)
+          unless template_filename
+            raise Goliath::Validation::InternalServerError, "Template #{data} not found in #{views} for #{engine}"
+          end
+
+          template = Tilt.new(template_filename, nil, options)
+          output = layout_template.render(scope, locals) do
+            template.render(scope, locals)
+          end
+
+        else
+          template = Tilt[engine].new(nil, nil, options){ data }
+          output = layout_template.render(scope, locals) do
+            template.render(scope, locals)
+          end
 
-        template = Tilt.new(template_filename, nil, options)
-        output = layout_template.render(scope, locals) do
-          template.render(scope, locals)
         end
 
         output.extend(ContentTyped).content_type = content_type if content_type

data/lib/goliath/rack/types/base.rb

@@ -0,0 +1,24 @@
+module Goliath
+  module Rack
+    module Types
+      class Base
+        include Goliath::Rack::Validator
+
+          def initialize
+            @short_name = self.class.name.split("::").last
+          end
+
+          def coerce(val, opts={})
+            begin
+              _coerce(val)
+            rescue => e
+              return opts[:default] if opts[:default]
+              raise Goliath::Rack::Validation::FailedCoerce.new(
+                validation_error(400, opts[:message] || e.message)
+              )
+            end
+          end
+      end
+    end
+  end
+end

data/lib/goliath/rack/types/boolean.rb

@@ -0,0 +1,18 @@
+module Goliath
+  module Rack
+    module Types
+      class Boolean < Base
+        TRUE_STRINGS = ['true', 't', '1']
+        FALSE_STRINGS = ['false', 'f', '0']
+        ERROR_MESSAGE = "%s is not a boolean value"
+
+        def _coerce(val)
+          downcased_val = val.downcase
+          return true if TRUE_STRINGS.include?(downcased_val)
+          return false if FALSE_STRINGS.include?(downcased_val)
+          raise ERROR_MESSAGE % val
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/types/core.rb

@@ -0,0 +1,19 @@
+module Goliath
+  module Rack
+    module Types
+      CORE_TYPES = [Integer, Float]
+
+      CORE_TYPES.each do |type|
+        klass = Class.new(Base)
+        klass.class_eval <<-EOT, __FILE__, __LINE__ + 1
+          def _coerce(val)
+            #{type}(val)
+          end
+        EOT
+
+        const_set(type.name, klass)
+      end
+    end
+  end
+end
+

data/lib/goliath/rack/types/symbol.rb

@@ -0,0 +1,16 @@
+module Goliath
+  module Rack
+    module Types
+      class Symbol < Base
+        ERROR_MESSAGE = "%s can't convert to Symbol"
+        def _coerce(val)
+          begin
+            val.to_sym
+          rescue
+            raise ERROR_MESSAGE % val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/types.rb

@@ -0,0 +1,10 @@
+module Goliath
+  module Rack
+    module Types
+      require 'goliath/rack/types/base'
+      require 'goliath/rack/types/core'
+      require 'goliath/rack/types/symbol'
+      require 'goliath/rack/types/boolean'
+    end
+  end
+end

data/lib/goliath/rack/validation/coerce.rb

@@ -0,0 +1,48 @@
+module Goliath
+  module Rack
+
+    module Validation
+      class FailedCoerce < StandardError
+        attr_reader :error
+        def initialize(error)
+          @error = error
+        end
+      end
+
+      module Coerce
+        NOT_CLASS_ERROR = "Params as must be a class"
+        INVALID_COERCE_TYPE = "%s does not respond to coerce"
+
+        def coerce_setup!(opts={})
+          as = opts.delete(:as)
+          if as
+            unless Class === as
+              raise Exception.new(NOT_CLASS_ERROR)
+            end
+            @coerce_instance = as.new
+            unless @coerce_instance.respond_to?(:coerce)
+              raise Exception.new(INVALID_COERCE_TYPE % @coerce_instance)
+            end
+          end
+        end
+
+        def call(env)
+          begin
+            coerce_value(env['params']) if @coerce_instance
+            nil
+          rescue FailedCoerce => e
+            return e.error unless @optional
+          end
+          super if defined?(super)
+        end
+
+        def coerce_value(params)
+          opts = {:default => @default, :message => @message}
+          value_before_coerce = fetch_key(params)
+          value_after_coerce = @coerce_instance.coerce(value_before_coerce, opts)
+          fetch_key(params, value_after_coerce)
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/validation/param.rb

@@ -0,0 +1,113 @@
+module Goliath
+  module Rack
+    module Validation
+      class FailedCoerce < StandardError
+        attr_reader :error
+        def initialize(error)
+          @error = error
+        end
+      end
+
+      # A middleware to validate that a given parameter is provided
+      # and/or coerce a given parameter to a given type.
+      #
+      # By default, Goliath supports Integer, Boolean, Float and Symbol.
+      # You can also create a custom coerce type by creating a
+      # class that has an instance method, coerce. Example:
+      #
+      # class CustomJSON
+      #   def coerce(value, opts={})
+      #     MultiJson.load(value)
+      #   end
+      # end
+      #
+      # Where value is the value that should be coerced and
+      # opts is a hash that contains two potential values:
+      #
+      # - default is the default value optionally specified in the middleware declaration.
+      #   This means default will be nil if it was not set.
+      # - message is the failure message optionally specified in the middleware declaration. This means message will be nil if it was not set.
+      #
+      # If default is not set, Integer, Boolean, Float and Symbol will return validation_error, otherwise params[key] will be set to default.
+      #
+      # If message is not set, it will have the error message of the exception caught by the coercion, otherwise the error message will be set to message.
+      #
+      # For your custom CoerceTypes, you can raise Goliath::Rack::Validation::FailedCoerce.new(value) where value is what will be returned from the call method.
+      #
+      # @example
+      #  use Goliath::Rack::Validation::Param, {:key => 'mode', :type => 'Mode'}
+      #  use Goliath::Rack::Validation::Param, {:key => 'data.credentials.login', :type => 'Login'}
+      #  use Goliath::Rack::Validation::Param, {:key => %w(data credentials password), :type => 'Password'}
+      #
+      #  use Goliath::Rack::Validation::CoerceValue, :key => 'flag', :as => Goliath::Rack::Types::Boolean
+      #
+      #  (or include Goliath::Rack::Types to reference the types without the namespaces.)
+      #
+      #  include Goliath::Rack::Types
+      #  use Goliath::Rack::Validation::Param, :key => 'amount', :as => Float
+      class Param
+        include Goliath::Rack::Validator
+        include Coerce
+        include Required
+        UKNOWN_OPTIONS = "Uknown options: %s"
+
+        attr_reader :key, :type, :optional, :message, :default
+
+        # Creates the Goliath::Rack::Validation::Param validator
+        #
+        # @param app The app object
+        # @param opts [Hash] The validator options
+        # @option opts [String] :key The key to look for in params (default: id)
+        #   if the value is an array it defines path with nested keys (ex: ["data", "login"] or
+        #   dot syntax: 'data.login')
+        # @option opts [String] :type The type string to put in the error message. (default: :key)
+        # @option opts [String] :message The message string to display after the type string. (default: 'identifier missing')
+        # @option opts [Class] :as The type to coerce params[key] to. (default: String)
+        # @option opts [String] :default (default: validation_error)
+        #
+        # @return [Goliath::Rack::Validation::Param] The validator
+        def initialize(app, opts = {})
+          @app = app
+          @optional = opts.delete(:optional) || false
+          @key = opts.delete(:key)
+          raise Exception.new("key option required") unless @key
+          
+          @type = opts.delete(:type) || @key
+          @message = opts.delete(:message) || 'identifier missing'
+          @default = opts.delete(:default)
+
+          coerce_setup!(opts)
+          required_setup!(opts)
+
+          raise Exception.new(UKNOWN_OPTIONS % opts.inspect) unless opts.empty?
+        end
+
+        def call(env)
+          previous_call = super
+          return previous_call if previous_call
+
+          @app.call(env)
+        end
+
+        def fetch_key(params, set_value=nil)
+          key_path = Array(@key)
+          current_value = params
+
+          # check that the full path is present
+          # omit the last part of the path
+          val = key_path[0...-1].each do |key_part|
+            # if the key is missing or is nil
+            if !current_value.is_a?(Hash) || current_value[key_part].nil?
+              break
+            end
+
+            current_value = current_value[key_part]
+          end
+
+          current_value[key_path[-1]] = set_value unless set_value.nil?
+          val.nil? ? val : current_value[key_path[-1]]
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/validation/request_method.rb

@@ -21,7 +21,7 @@ module Goliath
         # @return [Goliath::Rack::Validation::RequestMethod] The validator
         def initialize(app, methods = [])
           @app = app
-          @methods = methods
+          @methods = Array(methods)
         end
 
         def call(env)

data/lib/goliath/rack/validation/required.rb

@@ -0,0 +1,47 @@
+module Goliath
+  module Rack
+    module Validation
+      module Required
+        NON_WHITESPACE_REGEXP = %r![^[:space:]]!
+
+        def required_setup!(opts={})
+          if @key.is_a?(String) && @key.include?('.')
+            @key = @key.split('.')
+          end
+        end
+
+        def call(env)
+          unless @optional
+            return validation_error(400, "#{@type} #{@message}") unless key_valid?(env['params'])
+          end
+          super if defined?(super)
+        end
+
+        def key_valid?(params)
+          val = fetch_key(params)
+
+          case val
+          when nil
+            return false
+
+          when String
+            # if val is a string it must not be empty
+            return false if val !~ NON_WHITESPACE_REGEXP
+
+          when Array
+            unless val.compact.empty?
+              val.each do |k|
+                return true unless k.is_a?(String)
+                return true unless k !~ NON_WHITESPACE_REGEXP
+              end
+            end
+
+            return false
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/validation/required_param.rb

@@ -7,31 +7,35 @@ module Goliath
       #
       # @example
       #  use Goliath::Rack::Validation::RequiredParam, {:key => 'mode', :type => 'Mode'}
+      #  use Goliath::Rack::Validation::RequiredParam, {:key => 'data.credentials.login', :type => 'Login'}
+      #  use Goliath::Rack::Validation::RequiredParam, {:key => %w(data credentials password), :type => 'Password'}
       #
       class RequiredParam
         include Goliath::Rack::Validator
         attr_reader :type, :key, :message
 
         # extracted from activesupport 3.0.9
-        if defined?(Encoding) && "".respond_to?(:encode)
-          NON_WHITESPACE_REGEXP = %r![^[:space:]]!
-        else
-          NON_WHITESPACE_REGEXP = %r![^\s#{[0x3000].pack("U")}]!
-        end
-        
+        NON_WHITESPACE_REGEXP = %r![^[:space:]]!
+
         # Creates the Goliath::Rack::Validation::RequiredParam validator
         #
         # @param app The app object
         # @param opts [Hash] The validator options
         # @option opts [String] :key The key to look for in params (default: id)
+        #   if the value is an array it defines path with nested keys (ex: ["data", "login"] or
+        #   dot syntax: 'data.login')
         # @option opts [String] :type The type string to put in the error message. (default: :key)
         # @option opts [String] :message The message string to display after the type string. (default: 'identifier missing')
         # @return [Goliath::Rack::Validation::RequiredParam] The validator
         def initialize(app, opts = {})
           @app = app
           @key = opts[:key] || 'id'
-          @type = opts[:type] || @key.capitalize
+          @type = opts[:type] || @key
           @message = opts[:message] || 'identifier missing'
+
+          if @key.is_a?(String) && @key.include?('.')
+            @key = @key.split('.')
+          end
         end
 
         def call(env)
@@ -40,18 +44,39 @@ module Goliath
         end
 
         def key_valid?(params)
-          if !params.has_key?(key) || params[key].nil? ||
-              (params[key].is_a?(String) && params[key] !~ NON_WHITESPACE_REGEXP)
-            return false
-          end
+          key_path = Array(@key)
+          current_value = params
 
-          if params[key].is_a?(Array)
-            unless params[key].compact.empty?
-              params[key].each do |k|
-                return true unless k.is_a?(String)
-                return true unless k !~ NON_WHITESPACE_REGEXP
-              end
+          # check that the full path is present
+          # omit the last part of the path
+          key_path[0...-1].each do |key_part|
+            # if the key is missing or is nil the validation failed
+            if !current_value.is_a?(Hash) || current_value[key_part].nil?
+              return false
             end
+
+            current_value = current_value[key_part]
+          end
+
+          # if we are here the full path is available, now test the real key
+          val = current_value[key_path[-1]]
+
+          case val
+          when nil
+            return false
+
+          when String
+            # if val is a string it must not be empty
+            return false if val !~ NON_WHITESPACE_REGEXP
+
+          when Array
+            unless val.compact.empty?
+               val.each do |k|
+                 return true unless k.is_a?(String)
+                 return true unless k !~ NON_WHITESPACE_REGEXP
+               end
+             end
+
             return false
           end
 

data/lib/goliath/rack/validation.rb

@@ -1,6 +1,9 @@
 module Goliath
   module Rack
     module Validation
+      autoload :Coerce, 'goliath/rack/validation/coerce'
+      autoload :Required, 'goliath/rack/validation/required'
+      autoload :Param,  'goliath/rack/validation/param'
       autoload :BooleanValue,  'goliath/rack/validation/boolean_value'
       autoload :DefaultParams, 'goliath/rack/validation/default_params'
       autoload :NumericRange,  'goliath/rack/validation/numeric_range'

data/lib/goliath/rack.rb

@@ -6,6 +6,7 @@ module Goliath
     autoload :Builder,                'goliath/rack/builder'
     autoload :DefaultMimeType,        'goliath/rack/default_mime_type'
     autoload :DefaultResponseFormat,  'goliath/rack/default_response_format'
+    autoload :Favicon,                'goliath/rack/favicon'
     autoload :Formatters,             'goliath/rack/formatters'
     autoload :Heartbeat,              'goliath/rack/heartbeat'
     autoload :JSONP,                  'goliath/rack/jsonp'
@@ -15,9 +16,8 @@ module Goliath
     autoload :SimpleAroundwareFactory, 'goliath/rack/simple_aroundware_factory'
     autoload :Templates,              'goliath/rack/templates'
     autoload :Tracer,                 'goliath/rack/tracer'
+    autoload :Types,                 'goliath/rack/types'
     autoload :Validator,              'goliath/rack/validator'
     autoload :Validation,             'goliath/rack/validation'
-    #
-    autoload :AsyncAroundware,        'goliath/deprecated/async_aroundware'
   end
 end