restfulie 0.1.0.beta1

data/lib/restfulie/common/representation/atom.rb

@@ -0,0 +1,20 @@
+require 'nokogiri'
+
+module Restfulie
+  module Common
+    module Representation
+      module Atom
+        autoload :Factory, 'restfulie/common/representation/atom/factory'
+        autoload :XML, 'restfulie/common/representation/atom/xml'
+        autoload :Base, 'restfulie/common/representation/atom/base'
+        autoload :TagCollection, 'restfulie/common/representation/atom/tag_collection'
+        autoload :Link, 'restfulie/common/representation/atom/link'
+        autoload :Person, 'restfulie/common/representation/atom/person'
+        autoload :Category, 'restfulie/common/representation/atom/category'
+        autoload :Feed, 'restfulie/common/representation/atom/feed'
+        autoload :Entry, 'restfulie/common/representation/atom/entry'
+        autoload :Source, 'restfulie/common/representation/atom/source'
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/generic.rb

@@ -0,0 +1,22 @@
+module Restfulie
+  module Common
+    module Representation
+      # Unknown representation's unmarshalling on the client side
+      class Generic
+    
+        # Because there is no media type registered, return the content itself
+        def unmarshal(content)
+          def content.links
+            []
+          end
+          content
+        end
+    
+        def marshal(string, rel)
+          string
+        end
+    
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/json/base.rb

@@ -0,0 +1,27 @@
+module Restfulie
+  module Common
+    module Representation
+      class Json
+        module Base
+          module ClassMethods
+            
+            # creates a json unmarshalled version of this object
+            def create(obj = nil)
+              @json = {}
+              return @json.extend(KeysAsMethods) unless obj
+              
+              if obj.kind_of?(Hash) || obj.kind_of?(Array)
+                @json = obj
+              else 
+                @json = ::JSON.parse(obj)
+              end
+              
+              @json.extend(KeysAsMethods)
+            end
+            
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/json/keys_as_methods.rb

@@ -0,0 +1,74 @@
+module Restfulie
+  module Common
+    module Representation
+      class Json
+        module KeysAsMethods
+          def self.extended(base)
+            [:type, :id].each { |m| base.__free_method__(m) }      
+          end
+          
+          def [](key)
+            __normalize__(super(key))
+          end
+      
+          def []=(key, value)
+            super(key,value)
+          end
+      
+          def to_s
+            super.to_json
+          end
+      
+          def method_missing(name, *args)
+            method_name = name.to_s
+            if method_name.last == '='
+              self[method_name.chop] = args[0]
+            else
+              self[method_name]
+            end
+          end
+      
+          # if you have a key that is also a method (such as Array#size)
+          # you can use this to free the method and use the method obj.size
+          # to access the value of key "size".
+          # you still can access the old method with __[method_name]__
+          def __free_method__(sym)
+            if self.__metaclass__.method_defined?(sym) && !respond_to?("__#{sym}__")
+              self.__metaclass__.send(:alias_method, "__#{sym}__", sym)
+            end
+            self.__metaclass__.send(:define_method, sym) { method_missing(sym.to_s) }
+            self
+          end
+      
+          def __metaclass__
+            class << self; self; end
+          end
+          
+          include Restfulie::Common::Links
+
+          # easy accessors to links
+          def links
+            some_links = self["link"]
+            return nil unless some_links
+            some_links = [some_links] unless some_links.kind_of? Array
+            LinkCollection.new(some_links)
+          end
+              
+        private
+      
+          def __normalize__(value)
+            case value
+            when Hash
+              value.extend(KeysAsMethods)
+            when Array
+              value.map { |v| __normalize__(v) }
+            else
+              value
+            end
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/json/link.rb

@@ -0,0 +1,29 @@
+module Restfulie
+  module Common
+    module Representation
+      class Json
+        class Link
+          def initialize(obj)
+            @obj = obj
+          end
+          
+          def type
+            @obj.type
+          end
+          
+          def href
+            @obj.href
+          end
+          
+          def rel
+            @obj.rel
+          end
+              
+          def method_missing(symbol, *args, &block)
+            @obj.send(symbol, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/json/link_collection.rb

@@ -0,0 +1,23 @@
+module Restfulie
+  module Common
+    module Representation
+      class Json
+        class LinkCollection
+          def initialize(parent_node)
+            @node = parent_node
+          end
+          
+          def method_missing(symbol, *args, &block)
+            linkset = @node.select {|link| link.rel == symbol.to_s }
+            linkset.map! { |link| Link.new(link) }
+            unless linkset.empty?
+              linkset.size == 1 ? linkset.first : linkset
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/json.rb

@@ -0,0 +1,13 @@
+module Restfulie
+  module Common
+    module Representation
+      class Json
+        autoload :Base, 'restfulie/common/representation/json/base' 
+        autoload :KeysAsMethods, 'restfulie/common/representation/json/keys_as_methods' 
+        autoload :Link, 'restfulie/common/representation/json/link' 
+        autoload :LinkCollection, 'restfulie/common/representation/json/link_collection' 
+        extend Base::ClassMethods
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation/links.rb

@@ -0,0 +1,11 @@
+module Restfulie
+  module Common
+    module Representation
+      module Links
+        def self.extract_link_header(links)
+          links.collect {|link| "<#{link.href}>; rel=#{link.rel}"}.join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/representation.rb

@@ -0,0 +1,3 @@
+module Restfulie::Common::Representation
+  Dir["#{File.dirname(__FILE__)}/representation/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
+end

data/lib/restfulie/common.rb

@@ -0,0 +1,18 @@
+require 'net/http'
+require 'uri'
+
+require 'rubygems'
+require 'active_support'
+require 'action_controller'
+
+module Restfulie
+  module Common
+    autoload :Error, 'restfulie/common/error'
+    autoload :Links, 'restfulie/common/links'
+    autoload :Logger, 'restfulie/common/logger'
+    autoload :Representation, 'restfulie/common/representation'
+    autoload :Converter, 'restfulie/common/converter'
+  end
+end
+
+require 'restfulie/common/core_ext'

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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,12 @@
+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/cacheable.rb

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,17 @@
+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_controller/trait.rb

@@ -0,0 +1,9 @@
+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.rb

@@ -0,0 +1,11 @@
+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_view/helpers.rb

@@ -0,0 +1,50 @@
+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/tokamak.rb

@@ -0,0 +1,21 @@
+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/action_view/template_handlers.rb

@@ -0,0 +1,30 @@
+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.rb

@@ -0,0 +1,10 @@
+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