poncho 0.0.2

data/lib/poncho/param.rb

@@ -0,0 +1,29 @@
+module Poncho
+  class Param
+    def self.type
+      @type ||= begin
+        full_name = name.split('::').last
+        full_name = full_name.gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+        full_name.sub(/_param$/, '').to_sym
+      end
+    end
+
+    attr_reader :name, :options
+
+    def initialize(name, options = {})
+      @name    = name.to_sym
+      @options = options
+    end
+
+    def type
+      self.class.type
+    end
+
+    def validate_each(record, attribute, value)
+    end
+
+    def convert(value)
+      value
+    end
+  end
+end

data/lib/poncho/params.rb

@@ -0,0 +1,92 @@
+module Poncho
+  module Params
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      VALIDATES_DEFAULT_KEYS = [:resource, :type, :required, :format, :in, :not_in, :length]
+
+      def params
+        @params ||= {}
+      end
+
+      def param(name, options = {})
+        type  =  options[:type]
+        type ||= options[:resource] ? :resource : :string
+
+        klass = param_for_type(type)
+        param = klass.new(name, options)
+        params[param.name] = param
+
+        create_validations_for(param)
+
+        param
+      end
+
+      def string(name, options = {})
+        param(name, options.merge(:type => :string))
+      end
+
+      def integer(name, options = {})
+        param(name, options.merge(:type => :integer))
+      end
+
+      private
+
+      def param_for_type(type)
+        return type if type.is_a?(Class)
+        name = type.to_s.split('_').map {|w| w.capitalize }.join
+        const_get("#{name}Param")
+      rescue NameError
+        raise ArgumentError, "Unknown param: #{type}"
+      end
+
+      def create_validations_for(param)
+        attribute = param.name
+
+        unless param.options[:validates] == false
+          validates_param(attribute, :param => param)
+        end
+
+        if param.options[:required]
+          validates_presence_of(attribute)
+        end
+
+        if param.options[:format]
+          validates_format_of(attribute, :with => param.options[:format])
+        end
+
+        if param.options[:in]
+          validates_inclusion_of(attribute, :in => param.options[:in])
+        end
+
+        if param.options[:not_in]
+          validates_exclusion_of(attribute, :in => param.options[:not_in])
+        end
+
+        if param.options[:length]
+          length_options = case param.options[:length]
+          when Integer
+            {:minimum => 0, :maximum => param.options[:length]}
+          when Range
+            {:within => param.options[:length]}
+          when Hash
+            param.options[:length]
+          end
+          validates_length_of(attribute, length_options)
+        end
+
+        validators = param.options.reject {|key, _| VALIDATES_DEFAULT_KEYS.include?(key) }
+        validates(attribute, validators) if validators.any?
+      end
+    end
+  end
+
+  alias :param_for_validation? :respond_to?
+end
+
+Dir[File.dirname(__FILE__) + "/params/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "poncho/params/#{filename}"
+end

data/lib/poncho/params/array.rb

@@ -0,0 +1,15 @@
+module Poncho
+  module Params
+    class ArrayParam < Param
+      def validate_each(record, attribute, value)
+        if !value.is_a?(Array)
+          record.errors.add(attribute, :invalid_array, options.merge(:value => value))
+        end
+      end
+
+      def convert(value)
+        Array(value)
+      end
+    end
+  end
+end

data/lib/poncho/params/boolean.rb

@@ -0,0 +1,20 @@
+module Poncho
+  module Params
+    class BooleanParam < Param
+      def validate_each(record, attribute, value)
+        converted = convert(value)
+
+        if !(converted.is_a?(TrueClass) || converted.is_a?(FalseClass))
+          record.errors.add(attribute, :invalid_boolean, options.merge(:value => value))
+        end
+      end
+
+      def convert(value)
+        if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          return value
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/poncho/params/boolean_string.rb

@@ -0,0 +1,19 @@
+module Poncho
+  module Params
+    class BooleanStringParam < Param
+      def validate_each(record, attribute, value)
+        converted = convert(value)
+
+        if !(converted.is_a?(TrueClass) || converted.is_a?(FalseClass))
+          record.errors.add(attribute, :invalid_boolean_string, options.merge(:value => value))
+        end
+      end
+
+      def convert(value)
+        return true if value == 'yes'
+        return false if value == 'no'
+        nil
+      end
+    end
+  end
+end

data/lib/poncho/params/integer.rb

@@ -0,0 +1,17 @@
+module Poncho
+  module Params
+    class IntegerParam < Param
+      def validate_each(record, attribute, value)
+        unless convert(value).is_a?(Integer)
+          record.errors.add(attribute, :invalid_integer, options.merge(:value => value))
+        end
+      end
+
+      def convert(value)
+        Integer(value)
+      rescue TypeError, ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/poncho/params/object.rb

@@ -0,0 +1,15 @@
+module Poncho
+  module Params
+    class ObjectParam < Param
+      def validate_each(record, attribute, value)
+        if !value || !value.is_a?(Object)
+          record.errors.add(attribute, :invalid_object, options.merge(:value => value))
+        end
+      end
+
+      def convert(value)
+        value
+      end
+    end
+  end
+end

data/lib/poncho/params/resource.rb

@@ -0,0 +1,27 @@
+module Poncho
+  module Params
+    class ResourceParam < Param
+      def initialize(name, options = {})
+        super
+
+        unless options[:resource]
+          throw ArgumentError, ':resource required'
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        resource = convert(value)
+
+        unless resource.valid?
+          resource.errors.to_hash.each do |attr, messages|
+            record.messages[:"#{attribute}[#{attr}]"] |= messages
+         end
+        end
+      end
+
+      def convert(value)
+        options[:resource].new(value)
+      end
+    end
+  end
+end

data/lib/poncho/params/string.rb

@@ -0,0 +1,15 @@
+module Poncho
+  module Params
+    class StringParam < Param
+      def validate_each(record, attribute, value)
+        unless value.is_a?(String)
+          record.errors.add(attribute, :invalid_string, options.merge(:value => value))
+        end
+      end
+
+      def convert(value)
+        value && value.to_s
+      end
+    end
+  end
+end

data/lib/poncho/params/validations.rb

@@ -0,0 +1,24 @@
+module Poncho
+  module Validations
+    class ParamValidator < EachValidator
+      def check_validity!
+        unless options[:param]
+          raise ArgumentError, ':param option required'
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        if record.param_for_validation?(attribute)
+          options[:param].validate_each(record, attribute, value)
+        end
+      end
+    end
+
+    module HelperMethods
+      def validates_param(*attr_names)
+        options = attr_names.last.is_a?(::Hash) ? attr_names.pop : {}
+        validates_with ParamValidator, options.merge(:attributes => attr_names)
+      end
+    end
+  end
+end

data/lib/poncho/request.rb

@@ -0,0 +1,71 @@
+module Poncho
+  class Request < Rack::Request
+    # Returns an array of acceptable media types for the response
+    def accept
+      @env['poncho.accept'] ||= begin
+        entries = @env['HTTP_ACCEPT'].to_s.split(',')
+        entries.map { |e| accept_entry(e) }.sort_by(&:last).map(&:first)
+      end
+    end
+
+    def preferred_type(*types)
+      return accept.first if types.empty?
+      types.flatten!
+      accept.detect do |pattern|
+        type = types.detect { |t| File.fnmatch(pattern, t) }
+        return type if type
+      end
+    end
+
+    alias accept? preferred_type
+    alias secure? ssl?
+
+    def forwarded?
+      @env.include? 'HTTP_X_FORWARDED_HOST'
+    end
+
+    def safe?
+      get? or head? or options? or trace?
+    end
+
+    def idempotent?
+      safe? or put? or delete?
+    end
+
+    def params
+      @params ||= begin
+        params = super.merge(action_dispatch_params)
+        indifferent_params(params)
+      end
+    end
+
+    private
+
+    # Enable string or symbol key access to the nested params hash.
+    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
+
+    # Pass in params from Rails routing
+    def action_dispatch_params
+      action_dispatch_params = env['action_dispatch.request.path_parameters'] || {}
+      action_dispatch_params.inject({}) {|hash, (key, value)| hash[key.to_s] = value; hash }
+    end
+
+    def accept_entry(entry)
+      type, *options = entry.delete(' ').split(';')
+      quality = 0 # we sort smallest first
+      options.delete_if { |e| quality = 1 - e[2..-1].to_f if e.start_with? 'q=' }
+      [type, [quality, type.count('*'), 1 - options.size]]
+    end
+  end
+end

data/lib/poncho/resource.rb

@@ -0,0 +1,80 @@
+module Poncho
+  class Resource
+    include Params
+    include Validations
+
+    attr_reader :record
+
+    def initialize(record)
+      if record.nil?
+        raise ResourceValidationError, 'Invalid nil record'
+      end
+
+      @record = record
+    end
+
+    # Params
+
+    def param(name)
+      param = self.class.params[name]
+      raise Error, "Undefined param #{name}" unless param
+      param.convert(param_before_type_cast(name))
+    end
+
+    def param_before_type_cast(name)
+      record.send(name) if record.respond_to?(name)
+    end
+
+    alias_method :param?, :respond_to?
+
+    # Serialization
+
+    def each
+      [to_json]
+    end
+
+    def to_json(options = nil)
+      as_json.to_json
+    end
+
+    def as_json(options = nil)
+      validate!
+      to_hash
+    end
+
+    def to_hash
+      self.class.params.keys.inject({}) do |hash, key|
+        hash[key] = send(key)
+        hash
+      end
+    end
+
+    alias_method :describe, :to_hash
+
+    # Validation
+
+    # We want to validate an attribute if its
+    # uncoerced value is not nil
+    def param_for_validation?(name)
+      if respond_to?(name)
+        !send(name).nil?
+      else
+        !param_before_type_cast(name).nil?
+      end
+    end
+
+    alias_method :read_attribute_for_validation, :send
+
+    def validate!
+      raise ResourceValidationError, errors.to_s unless valid?
+    end
+
+    def method_missing(method_symbol, *arguments) #:nodoc:
+      if self.class.params.keys.include?(method_symbol)
+        return param(method_symbol)
+      end
+
+      super
+    end
+  end
+end

data/lib/poncho/response.rb

@@ -0,0 +1,28 @@
+module Poncho
+  class Response < Rack::Response
+    def body=(value)
+      value = value.body while Rack::Response === value
+      @body = String === value ? [value.to_str] : value
+    end
+
+    def each
+      block_given? ? super : enum_for(:each)
+    end
+
+    def finish
+      if status.to_i / 100 == 1
+        headers.delete 'Content-Length'
+        headers.delete 'Content-Type'
+      elsif Array === body and not [204, 304].include?(status.to_i)
+        # if some other code has already set Content-Length, don't muck with it
+        # currently, this would be the static file-handler
+        headers['Content-Length'] ||= body.inject(0) { |l, p| l + Rack::Utils.bytesize(p) }.to_s
+      end
+
+      # Rack::Response#finish sometimes returns self as response body. We don't want that.
+      status, headers, result = super
+      result = body if result == self
+      [status, headers, result]
+    end
+  end
+end