restfulie 0.1.0.beta1 → 0.1

data/lib/restfulie/server.rb

@@ -1,25 +0,0 @@
-require 'respondie'
-require 'restfulie/common'
-
-module Restfulie
-  module Server
-    autoload :Configuration, 'restfulie/server/configuration'
-    autoload :ActionController, 'restfulie/server/action_controller'
-    autoload :ActionView, 'restfulie/server/action_view'
-    autoload :Controller, 'restfulie/server/controller'
-  end
-end
-
-require 'restfulie/server/core_ext'
-Restfulie::Server::ActionView::TemplateHandlers.activate!
-
-class ActionController::Base
-  def self.restfulie
-    include Restfulie::Server::ActionController::Base
-  end
-  
-  def self.use_trait(&block)
-    Respondie::Builder.new("Restfulie::Server::ActionController::Trait::$trait$", self).instance_eval(&block)
-  end
-
-end

data/lib/restfulie/server/action_controller.rb

@@ -1,11 +0,0 @@
-module Restfulie
-  module Server
-    module ActionController #:nodoc:
-      if defined?(::ActionController) || defined?(::ApplicationController)
-        Dir["#{File.dirname(__FILE__)}/action_controller/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
-      end
-    end
-  end
-end
-
-require 'restfulie/server/action_controller/patch'

data/lib/restfulie/server/action_controller/base.rb

@@ -1,48 +0,0 @@
-module Restfulie
-  module Server
-    module ActionController
-      module Base
-        def self.included(base)
-          # Sets a default responder for this controller. 
-          # Needs to require responder_legacy.rb
-          base.responder = Restfulie::Server::ActionController::RestfulResponder
-          base.extend(Restfulie::Server::ActionController::Base::ClassMethods)
-          # Atom representation is added by default
-          Restfulie::Server::ActionController::ParamsParser.register('application/atom+xml', Restfulie::Common::Converter::Atom)
-        end
-
-        module ClassMethods
-          def call(env)
-            if include_restfulie? && env.has_key?("action_controller.restfulie.response")
-              if logger && logger.info?
-                information = "Status: #{env["action_controller.restfulie.response"][0]} "
-                information << ::ActionController::StatusCodes::STATUS_CODES[env["action_controller.restfulie.response"][0]]
-                logger.info(information) 
-              end
-              return env["action_controller.restfulie.response"] 
-            end
-            super
-          end
-
-          def include_restfulie?
-            defined?(Restfulie::Server::ActionController::Base) && self.include?(Restfulie::Server::ActionController::Base)
-          end
-        end
-        
-          # If your controller inherits from Restfulie::Server::Controller::Base,
-          # it will have an :atom option, very similar to render :xml
-          def render(options = nil, extra_options = {}, &block)
-            if options && atom = options[:atom]
-              response.content_type ||= Mime::ATOM
-              representation = atom.respond_to?(:to_atom) ? atom.to_atom.to_xml : atom.to_xml
-              options[:text] = representation
-              options[:atom] = nil
-              super options
-            else
-              super
-            end
-          end
-      end
-    end
-  end
-end

data/lib/restfulie/server/action_controller/params_parser.rb

@@ -1,100 +0,0 @@
-module Restfulie
-  module Server
-    module ActionController
-      
-      # This class is just a proxy for the extension point offered by ActionDispatch::ParamsParser
-      class ParamsParser3
-        
-        def register(content_type, representation)
-          ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime::Type.lookup(content_type)] = representation.method(:to_hash).to_proc
-        end
-        
-        def unregister(content_type)
-          ActionDispatch::ParamsParser::DEFAULT_PARSERS.delete(Mime::Type.lookup(content_type))
-        end
-      end
-
-      # This class is just a proxy for the extension point offered by ActionController::Base
-      class ParamsParser2
-
-        def param_parsers
-          ::ActionController::Base.param_parsers
-        end
-
-        def register(content_type, representation)
-          param_parsers[Mime::Type.lookup(content_type)] = representation.method(:to_hash).to_proc
-        end
-        
-        def unregister(content_type)
-          param_parsers.delete(Mime::Type.lookup(content_type))
-        end
-      end
-      
-      
-      class ParamsParser
-        
-        def self.rails3?
-          defined?(::ActionDispatch) && defined?(::ActionDispatch::ParamsParser)
-        end
-
-        if rails3?
-          @parser = ParamsParser3.new
-        else
-          @parser = ParamsParser2.new
-          # This monkey patch is needed because Rails 2.3.5 doesn't support
-          # a way of use rescue_from ActionController handling to return
-          # bad request status when trying to parse an invalid body request
-          #
-          # In Rails 3 this won't be necessary, because all exception handling
-          # extensions are handled by the Rack stack
-          #
-          # TODO Change this when porting this code to Rails 3
-          ::ActionController::ParamsParser.class_eval do
-            def call(env)
-              begin
-                if params = parse_formatted_parameters(env)
-                  env["action_controller.request.request_parameters"] = params
-                elsif !(env["CONTENT_TYPE"] == "application/x-www-form-urlencoded") #do not override rails default behaviour for this media type, it's dangerous... (o.O)
-                  if env["CONTENT_LENGTH"] && (env["CONTENT_LENGTH"] != "0")
-                    env["action_controller.restfulie.response"] = [415, {'Content-Type' => 'text/html'}, ["<html><body><h1>415 Unsupported Media Type</h1></body></html>"]]
-                  end
-                end
-              rescue
-                env["action_controller.restfulie.response"] = [400, {'Content-Type' => 'text/html'}, ["<html><body><h1>400 Bad Request</h1></body></html>"]]
-              end
-
-              @app.call(env)
-            end
-          end
-        end
-        
-        ## 
-        # :singleton-method:
-        # Use it to register param parsers on the server side.
-        #
-        # * <tt>media type</tt>
-        # * <tt>a restfulie representation with to_hash method</tt>
-        #
-        #   Restfulie::Server::ActionController::ParamsParser.register('application/atom+xml', Atom)
-        #
-        def self.register(content_type, representation)
-          @parser.register(content_type, representation)
-        end
-
-        ## 
-        # :singleton-method:
-        # Use it to unregister param parsers on the server side.
-        #
-        # * <tt>media type</tt>
-        #
-        #   Restfulie::Server::ActionController::ParamsParser.unregister('application/atom+xml')
-        #
-        def self.unregister(content_type)
-          @parser.unregister(content_type)
-        end
-      end
-      
-    end
-  end
-end
-

data/lib/restfulie/server/action_controller/patch.rb

@@ -1,6 +0,0 @@
-module ActionController::Routing
-  HTTP_METHODS = [:get, :head, :post, :put, :delete, :options, :patch]
-end
-
-ActionController::Request::HTTP_METHODS << "patch"
-ActionController::Request::HTTP_METHOD_LOOKUP["PATCH"] = :patch

data/lib/restfulie/server/action_controller/restful_responder.rb

@@ -1,12 +0,0 @@
-module Restfulie
-  module Server
-    module ActionController
-      class RestfulResponder < ::ActionController::Responder
-        
-        include CacheableResponder
-        include CreatedResponder
-
-      end
-    end
-  end
-end

data/lib/restfulie/server/action_controller/trait.rb

@@ -1,9 +0,0 @@
-module Restfulie
-  module Server
-    module ActionController #:nodoc:
-      module Trait #:nodoc:
-        Dir["#{File.dirname(__FILE__)}/trait/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
-      end
-    end
-  end
-end

data/lib/restfulie/server/action_controller/trait/cacheable.rb

@@ -1,81 +0,0 @@
-class Expires
-  def do_http_cache(responder, headers)
-    if responder.options[:expires_in]
-      headers << "max-age=#{responder.options[:expires_in]}"
-      true
-    else
-      false
-    end
-  end
-end
-
-class LastModifieds
-  # default implementation that will check whether caching can be applied
-  def accepts?(responder)
-    responder.resources.flatten.select do |resource|
-      resource.respond_to?(:updated_at)
-    end &&
-      responder.controller.response.last_modified.nil? &&
-      !new_record?(responder)
-  end
-
-  def do_http_cache(responder, headers)
-    return false unless accepts?(responder)
-    
-    timestamps = responder.resources.flatten.select do |resource|
-      resource.respond_to?(:updated_at)
-    end.map do |resource|
-      (resource.updated_at || Time.now).utc
-    end
-    
-    timestamp = timestamps.max
-
-    responder.controller.response.last_modified = timestamp if timestamp
-  end
-
-  def new_record?(responder)
-    responder.resource.respond_to?(:new_record?) && responder.resource.new_record?
-  end
-    
-end
-
-module Restfulie::Server::ActionController
-  module Trait
-    module Cacheable
-      
-      CACHES = [::Expires.new, ::LastModifieds.new]
-      
-      def to_format
-        headers = cache_control_headers
-        cached = CACHES.inject(false) do |cached, cache|
-          cached || cache.do_http_cache(self, headers)
-        end
-        if ::ActionController::Base.perform_caching && cached
-          set_public_cache_control(headers)
-          controller.response.headers["Cache-Control"] = headers.join(', ')
-          fresh = request.fresh?(controller.response)
-          if fresh
-            head :not_modified
-          else
-            super
-          end
-        else
-          super
-        end
-      end
-      
-      private
-        
-      def set_public_cache_control(headers)
-        headers.delete("private")
-        headers.delete("no-cache")
-        headers << "public"
-      end
-      
-      def cache_control_headers
-        (controller.response.headers["Cache-Control"] || "").split(",").map {|k| k.strip }
-      end
-
-    end
-  end
-end

data/lib/restfulie/server/action_controller/trait/created.rb

@@ -1,17 +0,0 @@
-module Restfulie::Server::ActionController
-  module Trait
-    
-    # Adds support to answering as a 201 when the resource has been just created
-    module Created
-
-      def to_format
-        if (options[:status] == 201) || (options[:status] == :created)
-          render :status => 201, :location => controller.url_for(resource), :text => ""
-        else
-          super
-        end
-      end
-
-    end
-  end
-end

data/lib/restfulie/server/action_view.rb

@@ -1,10 +0,0 @@
-if defined? ::ActionView and ::ActionController
-  module Restfulie #:nodoc:
-    module Server #:nodoc:
-      module ActionView #:nodoc:
-        autoload :TemplateHandlers, 'restfulie/server/action_view/template_handlers'
-        autoload :Helpers, 'restfulie/server/action_view/helpers'
-      end
-    end
-  end
-end

data/lib/restfulie/server/action_view/helpers.rb

@@ -1,50 +0,0 @@
-module Restfulie
-  module Server
-    module ActionView
-      module Helpers
-        # Load a partial template to execute in describe
-        #
-        # For example:
-        #
-        # Passing the current context to partial in template:
-        #
-        #  member(@album) do |member, album|
-        #    partial('member', binding)
-        #  end
-        #
-        # in partial:
-        #
-        #  member.links << link(:rel => :artists, :href => album_artists_url(album))
-        #
-        # Or passing local variables assing
-        #
-        # collection(@albums) do |collection|
-        #   collection.members do |member, album|
-        #     partial("member", :locals => {:member => member, :album => album})
-        #   end
-        # end
-        #
-        def partial(partial_path, caller_binding = nil)
-          # Create a context to assing variables
-          if caller_binding.kind_of?(Hash)
-            Proc.new do
-              extend @restfulie_type_helpers
-              context = eval("(class << self; self; end)", binding)
-              
-              unless caller_binding[:locals].nil?
-                caller_binding[:locals].each do |k, v|
-                  context.send(:define_method, k.to_sym) { v }
-                end
-              end
-              
-              partial(partial_path, binding)
-            end.call
-          else
-            template = _pick_partial_template(partial_path)
-            eval(template.source, caller_binding, template.path)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/restfulie/server/action_view/template_handlers.rb

@@ -1,30 +0,0 @@
-module Restfulie
-  module Server
-    module ActionView
-      module TemplateHandlers #:nodoc:
-        autoload :Tokamak, 'restfulie/server/action_view/template_handlers/tokamak'
-        
-        def self.template_registry
-          if defined? ::ActionView::Template and 
-            ::ActionView::Template.respond_to?(:register_template_handler)
-              ::ActionView::Template
-          else
-            ::ActionView::Base
-          end
-        end
-        
-        # It is needed to explicitly call 'activate!' to install the Tokamak
-        # template handler
-        def self.activate!
-          template_registry.register_template_handler(:tokamak, 
-                Restfulie::Server::ActionView::TemplateHandlers::Tokamak)
-      
-          # TODO unsure if it can be removed. check feedback prior to 1.0.0
-          # if defined?(::ActionController::Base) && ::ActionController::Base.respond_to?(:exempt_from_layout)
-            # ::ActionController::Base.exempt_from_layout :tokamak 
-          # end    
-        end
-      end
-    end
-  end
-end

data/lib/restfulie/server/action_view/template_handlers/tokamak.rb

@@ -1,21 +0,0 @@
-module Restfulie
-  module Server
-    module ActionView
-      module TemplateHandlers
-        class Tokamak < ::ActionView::TemplateHandler
-          include ::ActionView::TemplateHandlers::Compilable
-            
-          def compile(template)
-            "@restfulie_type_helpers = Restfulie::Common::Converter.content_type_for(self.response.content_type).helper; " +
-            "extend @restfulie_type_helpers; " +
-            "extend Restfulie::Server::ActionView::Helpers; " +
-            "code_block = lambda { #{template.source} };" + 
-            "builder = code_block.call; " +
-            "self.response.headers['Link'] = Restfulie::Common::Representation::Links.extract_link_header(builder.links) if builder.respond_to?(:links); " +
-            "builder.to_s"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/restfulie/server/configuration.rb

@@ -1,24 +0,0 @@
-module Restfulie
-  module Server
-    module Configuration
-      # Defines host to be passed to polymorphic_url.
-      # You need to setup this to your own domain in order to generate meaningful links.
-      mattr_accessor :host
-      @@host = 'localhost'
-      
-      # Passes a symbol to polymorphic_url in order to use a namespaced named_route.
-      # So, if config.named_route_prefix = :rest, it will search for rest_album_url,
-      # rest_album_songs_url, and so on.
-      mattr_accessor :named_route_prefix
-      @@named_route_prefix = nil
-            
-      # This defines a Rails-like way to setup options. You can do, in a initializer:
-      #   Restfulie::Server.setup do |config|
-      #     config.host = 'mydomain.com'
-      #   end
-      def self.setup
-        yield self
-      end
-    end
-  end
-end