poncho 0.0.2

data/lib/poncho/error.rb

@@ -0,0 +1,75 @@
+module Poncho
+  class Error < StandardError
+    def to_json
+      as_json.to_json
+    end
+
+    def type
+      inspect
+    end
+
+    def as_json
+      {:error => {:type => type, :message => message}}
+    end
+  end
+
+  class ServerError < Error
+    def code
+      500
+    end
+
+    def type
+      :server_error
+    end
+
+    def message
+      "Sorry, something went wrong. " +
+      "We've been notified about the problem."
+    end
+  end
+
+  class ResourceValidationError < ServerError
+  end
+
+  class ClientError < Error
+    attr_reader :type, :message
+
+    def initialize(type = nil, message = nil)
+      @type    = type || self.class.name
+      @message = message
+    end
+
+    def code
+      400
+    end
+  end
+
+  class InvalidRequest < ClientError
+  end
+
+  class ValidationError < ClientError
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+    end
+
+    def code
+      406
+    end
+
+    def as_json
+      errors
+    end
+  end
+
+  class NotFoundError < ClientError
+    def code
+      404
+    end
+
+    def type
+      :not_found
+    end
+  end
+end

data/lib/poncho/errors.rb

@@ -0,0 +1,142 @@
+module Poncho
+  class Errors
+    attr_reader :messages
+
+    def initialize(base)
+      @base     = base
+      @messages = {}
+    end
+
+    # Clear the messages
+    def clear
+      messages.clear
+    end
+
+    # Do the error messages include an error with key +error+?
+    def include?(error)
+      (v = messages[error]) && v.any?
+    end
+    alias_method :has_key?, :include?
+
+    # Get messages for +key+
+    def get(key)
+      messages[key]
+    end
+
+    # Set messages for +key+ to +value+
+    def set(key, value)
+      messages[key] = value
+    end
+
+    # Delete messages for +key+
+    def delete(key)
+      messages.delete(key)
+    end
+
+    # When passed a symbol or a name of a method, returns an array of errors
+    # for the method.
+    #
+    #   p.errors[:name]   # => ["can not be nil"]
+    #   p.errors['name']  # => ["can not be nil"]
+    def [](attribute)
+      get(attribute.to_sym) || set(attribute.to_sym, [])
+    end
+
+    # Adds to the supplied attribute the supplied error message.
+    #
+    #   p.errors[:name] = "must be set"
+    #   p.errors[:name] # => ['must be set']
+    def []=(attribute, error)
+      self[attribute] << error
+    end
+
+    def each
+      [to_s]
+    end
+
+    # Returns the number of error messages.
+    #
+    #   p.errors.add(:name, "can't be blank")
+    #   p.errors.size # => 1
+    #   p.errors.add(:name, "must be specified")
+    #   p.errors.size # => 2
+    def size
+      values.flatten.size
+    end
+
+    # Returns all message values
+    def values
+      messages.values
+    end
+
+    # Returns all message keys
+    def keys
+      messages.keys
+    end
+
+    def to_s
+      "Validation errors:\n " + full_messages.join(', ')
+    end
+
+    # Returns an array of error messages, with the attribute name included
+    #
+    #   p.errors.add(:name, "can't be blank")
+    #   p.errors.add(:name, "must be specified")
+    #   p.errors.to_a # => ["name can't be blank", "name must be specified"]
+    def to_a
+      full_messages
+    end
+
+    # Returns the number of error messages.
+    #   p.errors.add(:name, "can't be blank")
+    #   p.errors.count # => 1
+    #   p.errors.add(:name, "must be specified")
+    #   p.errors.count # => 2
+    def count
+      to_a.size
+    end
+
+    # Returns true if no errors are found, false otherwise.
+    # If the error message is a string it can be empty.
+    def empty?
+      messages.all? { |k, v| v && v == "" && !v.is_a?(String) }
+    end
+    alias_method :blank?, :empty?
+
+    # Return the first error we get
+    def as_json(options=nil)
+      return {} if messages.empty?
+      attribute, types = messages.first
+      type             = types.first
+
+      {
+        :error => {
+          :param => attribute,
+          :type  => type,
+          :message => nil
+        }
+      }
+    end
+
+    def to_json(options=nil)
+      as_json.to_json
+    end
+
+    def to_hash
+      messages.dup
+    end
+
+    def add(attribute, message = nil, options = {})
+      self[attribute] << message
+    end
+
+    def full_messages
+      messages.map { |attribute, message| full_message(attribute, message) }
+    end
+
+    def full_message(attribute, message)
+      return message if attribute == :base
+      "#{attribute} #{message.join(', ')}"
+    end
+  end
+end

data/lib/poncho/filters.rb

@@ -0,0 +1,52 @@
+module Poncho
+  module Filters
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    class Filter
+      attr_reader :options, :block
+
+      def initialize(options = {}, &block)
+        @options = options
+        @block   = block
+      end
+
+      def to_proc
+        block.to_proc
+      end
+
+      def call(*args)
+        block.call(*args)
+      end
+    end
+
+    module InstanceMethods
+      def run_filters(type)
+        self.class.run_filters(type, self)
+      end
+    end
+
+    module ClassMethods
+      def filters
+        @filters ||= Hash.new {[]}
+      end
+
+      def add_filter(type, options = {}, &block)
+        filters[type] << Filter.new(options, &block)
+      end
+
+      def run_filters(type, binding = self)
+        base = self
+
+        while base.respond_to?(:filters)
+          base.filters[type].each {|f| binding.instance_eval(&f) }
+          base = base.superclass
+        end
+      end
+    end
+  end
+end

data/lib/poncho/json_method.rb

@@ -0,0 +1,47 @@
+begin
+  require 'json'
+rescue LoadError => e
+  require 'json/pure'
+end
+
+module Poncho
+  class JSONMethod < Method
+    error 500 do
+      json ServerError.new
+    end
+
+    error 403 do
+      json InvalidRequestError.new
+    end
+
+    error 404 do
+      json NotFoundError.new
+    end
+
+    error ValidationError do
+      json env['poncho.error'].errors
+    end
+
+    def body(value = nil)
+      if value && !json_content_type?
+        content_type :json
+        value = value.to_json
+      end
+
+      super
+    end
+
+    def json(value)
+      content_type :json
+      body(value.to_json)
+    end
+
+    def json?
+      request.accept?(mime_type(:json))
+    end
+
+    def json_content_type?
+      response['Content-Type'] == mime_type(:json)
+    end
+  end
+end

data/lib/poncho/method.rb

@@ -0,0 +1,271 @@
+module Poncho
+  class Method
+    include Validations
+    include Filters
+    include Params
+
+    def self.call(env, params = {})
+      self.new.call(env, params)
+    end
+
+    # Some magic so you can do one-line
+    # Sinatra routes. For example:
+    #   get '/charges', &ChargesListMethod
+    def self.to_proc
+      this = self
+      Proc.new { this.call(env, params) }
+    end
+
+    # Filters
+
+    def self.before(options = {}, &block)
+      add_filter(:before, options, &block)
+    end
+
+    def self.before_validation(options = {}, &block)
+      add_filter(:before_validation, options, &block)
+    end
+
+    def self.errors
+      @errors ||= {}
+    end
+
+    def self.error(type = :base, &block)
+      errors[type] = block
+    end
+
+    def self.helpers(*extensions, &block)
+      class_eval(&block)   if block_given?
+      include(*extensions) if extensions.any?
+    end
+
+    attr_reader :env, :request, :response
+
+    def call(env, params = {})
+      @env      = env
+      @request  = Request.new(env)
+      @response = Response.new
+
+      # Extra params, say from Sinatra's routing
+      @request.params.merge!(params)
+
+      wrap {
+        validate!
+        dispatch!
+      }
+
+      unless @response['Content-Type']
+        if Array === body and body[0].respond_to? :content_type
+          content_type body[0].content_type
+        else
+          content_type :html
+        end
+      end
+
+      @response.finish
+    end
+
+    def headers(hash=nil)
+      response.headers.merge! hash if hash
+      response.headers
+    end
+
+    def params
+      request.params.inject({}) do |hash, (key, _)|
+        hash[key.to_sym] = param(key)
+        hash
+      end
+    end
+
+    def param(name)
+      value = param_before_type_cast(name)
+      param = self.class.params[name.to_sym]
+      param ? param.convert(value) : value
+    end
+
+    def param?(name)
+      request.params.has_key?(name.to_s)
+    end
+
+    def param_before_type_cast(name)
+      request.params[name.to_s]
+    end
+
+    def status(value=nil)
+      response.status = value if value
+      response.status
+    end
+
+    def redirect(uri, *args)
+      if env['HTTP_VERSION'] == 'HTTP/1.1' and env['REQUEST_METHOD'] != 'GET'
+        status 303
+      else
+        status 302
+      end
+      response['Location'] = uri
+      halt(*args)
+    end
+
+    def content_type(type = nil, params = {})
+      return response['Content-Type'] unless type
+      default = params.delete :default
+      mime_type = mime_type(type) || default
+      fail "Unknown media type: %p" % type if mime_type.nil?
+      response['Content-Type'] = mime_type.dup
+    end
+
+    def body(value = nil, &block)
+      if block_given?
+        def block.each; yield(call) end
+        response.body = block
+      elsif value
+        response.body = value
+      else
+        response.body
+      end
+    end
+
+    # Statuses
+
+    # whether or not the status is set to 2xx
+    def success?
+      status.between? 200, 299
+    end
+
+    # whether or not the status is set to 3xx
+    def redirect?
+      status.between? 300, 399
+    end
+
+    # whether or not the status is set to 4xx
+    def client_error?
+      status.between? 400, 499
+    end
+
+    # whether or not the status is set to 5xx
+    def server_error?
+      status.between? 500, 599
+    end
+
+    # whether or not the status is set to 404
+    def not_found?
+      status == 404
+    end
+
+    # Errors
+
+    def halt(*response)
+      response = response.first if response.length == 1
+      throw :halt, response
+    end
+
+    def error(code, body=nil)
+      code, body = 500, code.to_str if code.respond_to? :to_str
+      self.body(body) unless body.nil?
+      halt code
+    end
+
+    def not_found(body=nil)
+      error 404, body
+    end
+
+    # Implement
+
+    def invoke
+    end
+
+    # Validation
+
+    alias_method :read_attribute_for_validation, :param_before_type_cast
+    alias_method :param_for_validation?, :param?
+
+    protected
+
+    def validate!
+      run_filters :before_validation
+      run_extra_param_validations!
+      run_validations!
+      raise ValidationError.new(errors) unless errors.empty?
+    ensure
+      run_filters :after_validation
+    end
+
+    DEFAULT_PARAMS = %w{splat captures action controller}
+
+    def run_extra_param_validations!
+      (request.params.keys - DEFAULT_PARAMS).each do |param|
+        unless self.class.params.has_key?(param.to_sym)
+          errors.add(param, :invalid_param)
+        end
+      end
+    end
+
+    # Calling
+
+    def dispatch!
+      run_filters :before
+      invoke
+    ensure
+      run_filters :after
+    end
+
+    def error_block(key)
+      base = self.class
+
+      while base.respond_to?(:errors)
+        block = base.errors[key]
+        return block if block
+        base = base.superclass
+      end
+
+      return false unless key.respond_to?(:superclass) && key.superclass < Exception
+      error_block(key.superclass)
+    end
+
+    def handle_exception!(error)
+      env['poncho.error'] = error
+
+      status error.respond_to?(:code) ? Integer(error.code) : 500
+
+      if server_error?
+        request.logger.error(
+          "#{error.class}: #{error}\n\t" +
+          error.backtrace.join("\n\t")
+        )
+      end
+
+      block   = error_block(error.class)
+      block ||= error_block(status)
+      block ||= error_block(:base)
+
+      if block
+        wrap {
+          instance_eval(&block)
+        }
+      else
+        raise error if server_error?
+      end
+    end
+
+    def wrap
+      res = catch(:halt) { yield }
+      res = [res] if Fixnum === res or String === res
+      if Array === res and Fixnum === res.first
+        status(res.shift)
+        body(res.pop)
+        headers(*res)
+      elsif res.respond_to? :each
+        body res
+      end
+    rescue ::Exception => e
+      handle_exception!(e)
+    end
+
+    def mime_type(type, value=nil)
+      return type if type.nil? || type.to_s.include?('/')
+      type = ".#{type}" unless type.to_s[0] == ?.
+      return Rack::Mime.mime_type(type, nil) unless value
+      Rack::Mime::MIME_TYPES[type] = value
+    end
+  end
+end