restfulie 0.6.0 → 0.7.0

data/lib/restfulie/common/builder/rules/rules_base.rb

@@ -0,0 +1,76 @@
+module Restfulie::Common::Builder::Rules; end
+
+class Restfulie::Common::Builder::Rules::Base
+  attr_accessor :blocks
+  attr_accessor :links
+  attr_reader :namespaces
+
+  def initialize(blocks = [], &block)
+    @links  = Restfulie::Common::Builder::Rules::Links.new
+    @blocks = (block_given? ? [block] : []) + blocks
+    @namespaces = []
+  end
+
+  def apply(*args)
+    @blocks.each do |block|
+      params = ([self] + args)[0..block.arity-1]
+      block.call(*params)
+    end
+  end
+
+  # Use to register namespace
+  #
+  #==Example:
+  #
+  #  namespace(@album , "http://example.com")
+  #  namespace(:albums, "http://example.com")
+  #  namespace(:albums, "http://example.com", :eager_load => false)
+  #  namespace(:albums, "http://example.com", :eager_load => { :title => 'A title' })
+  #
+  def namespace(ns, uri = nil, options = {}, &block)
+    object = nil
+    
+    if !ns.kind_of?(String) && !ns.kind_of?(Symbol)
+      object = ns
+      ns = object.class.to_s.demodulize.downcase.pluralize.to_sym
+      options[:eager_load] = true unless options.key?(:eager_load)
+    end
+    
+    unless [true, false, nil].include?(options[:eager_load])
+      object = options[:eager_load]
+      options[:eager_load] = true
+    end
+    
+    namespace = find_or_new_namespace(ns, uri)
+    eager_load(object, namespace) if options[:eager_load]
+    
+    yield(namespace) if block_given?
+    namespace
+  end
+
+  def metaclass
+    (class << self; self; end)
+  end
+
+private
+  # Load attributes of the object to passed hash.
+  # If object respond to attributes, attributes is merge, unless merge instance variables
+  def eager_load(object, ns)
+    if object.kind_of?(Hash)
+      ns.merge!(object.symbolize_keys)
+    elsif object.respond_to?(:attributes)
+      ns.merge!(object.attributes.symbolize_keys)
+    else
+      object.instance_variables.each do |var|
+        ns[var.gsub(/^@/, '').to_sym] = object.instance_variable_get(var)
+      end
+    end
+  end
+
+  # Search a namespace or create a new
+  def find_or_new_namespace(name, uri)
+    namespace = @namespaces.find { |n| n.namespace == name } || (@namespaces << Restfulie::Common::Builder::Rules::Namespace.new(name, uri)).last
+    namespace.uri = uri unless uri.nil?
+    namespace
+  end
+end

data/lib/restfulie/common/builder.rb

@@ -0,0 +1,16 @@
+#initialize namespace
+module Restfulie::Common::Builder; end
+
+%w(
+  helpers
+  builder_base
+  marshalling
+  rules/rules_base
+  rules/link
+  rules/links
+  rules/namespace
+  rules/member_rule
+  rules/collection_rule
+).each do |file|
+  require File.join(File.dirname(__FILE__), 'builder', file)
+end

data/lib/restfulie/common/errors.rb

@@ -0,0 +1,9 @@
+module Restfulie::Common::Error
+  class RestfulieError < StandardError; end
+  class MarshallingError < RestfulieError; end
+  class UndefinedMarshallingError < MarshallingError; end
+  
+  # Atom marshallinh error
+  class AtomMarshallingError < MarshallingError; end
+  class NameSpaceError < AtomMarshallingError; end
+end

data/lib/restfulie/{logger.rb → common/logger.rb}

@@ -1,13 +1,11 @@
-module Restfulie 
-
+module Restfulie::Common::Logger
   # Configure the logger used by Restfulie
   # 
   # The logger defaults to ActiveSupport::BufferedLogger.new(STDOUT)
   class << self
     attr_accessor :logger
   end
-
 end
 
-Restfulie.logger = ActiveSupport::BufferedLogger.new(STDOUT)
-Restfulie.logger.level = Logger::DEBUG
+Restfulie::Common::Logger.logger = ActiveSupport::BufferedLogger.new(STDOUT)
+Restfulie::Common::Logger.logger.level = Logger::DEBUG

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

@@ -0,0 +1,48 @@
+module Restfulie::Common::Representation
+  # Implements the interface for unmarshal Atom media type responses (application/atom+xml) to ruby objects instantiated by rAtom library.
+  #
+  # Furthermore, this class extends rAtom behavior to enable client users to easily access link relationships.
+  class Atom
+
+    cattr_reader :media_type_name
+    @@media_type_name = 'application/atom+xml'
+
+    cattr_reader :headers
+    @@headers = { 
+      :get  => { 'Accept'       => media_type_name },
+      :post => { 'Content-Type' => media_type_name }
+    }
+
+    #Convert raw string to rAtom instances (client side)
+    def unmarshal(content)
+      begin
+        ::Atom::Feed.load_feed(content)
+      rescue ::ArgumentError
+        ::Atom::Entry.load_entry(content)
+      end
+    end
+
+    def marshal(string, rel)
+      string
+    end
+
+    # transforms this content into a parameter hash for rails (server-side usage)
+    def self.to_hash(content)
+      Hash.from_xml(content).with_indifferent_access
+    end
+    
+    def prepare_link_for(link)
+      link
+    end
+    
+    def prepare_link_for(link)
+      link
+    end
+    
+    def prepare_link_for(link)
+      link
+    end
+  end
+
+end
+

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

@@ -0,0 +1,33 @@
+module Restfulie::Common::Representation
+  # Unknown representation's unmarshalling on the client side
+  class Generic
+
+    def self.media_type_name
+      raise Restfulie::Common::Error::RestfulieError.new("Generic representation does not have a specific media type")
+    end
+
+    cattr_reader :headers
+    @@headers = { 
+      :get  => { },
+      :post => { }
+    }
+
+    # 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
+
+    def prepare_link_for(link)
+      link
+    end
+  end
+
+end
+

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

@@ -0,0 +1,24 @@
+module Restfulie::Common::Representation
+  # Implements the interface for marshal Xml media type requests (application/xml)
+  class XmlD
+
+    cattr_reader :media_type_name
+    @@media_type_name = 'application/xml'
+
+    cattr_reader :headers
+    @@headers = { 
+      :post => { 'Content-Type' => media_type_name }
+    }
+
+    def unmarshal(string)
+      raise "should never be invoked, xml to ruby objects should be handled by rails itself"
+    end
+
+    def marshal(string, rel)
+      string
+    end
+
+  end
+
+end
+

data/lib/restfulie/common/representation.rb

@@ -0,0 +1,10 @@
+#initialize namespace
+module Restfulie::Common::Representation; end
+
+%w(
+  atom
+  xml
+).each do |file|
+  require File.join(File.dirname(__FILE__), 'representation', file)
+end
+

data/lib/restfulie/common.rb

@@ -0,0 +1,23 @@
+require 'net/http'
+require 'uri'
+
+require 'rubygems'
+require 'active_support'
+require 'action_controller'
+
+require 'vendor/atom'
+
+module Restfulie
+  module Common; end
+end
+
+%w(
+  errors
+  logger
+  builder
+  representation
+).each do |file| 
+  require "restfulie/common/#{file}"
+end
+
+include ActiveSupport::CoreExtensions::Hash

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

@@ -0,0 +1,31 @@
+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
+          # Atom representation is added by default
+          ParamsParser.register('application/atom+xml', Restfulie::Common::Representation::Atom)
+        end
+
+      protected
+      
+        # If your controller inherits from Restfulie::Server::Controller::Base,
+        # it will have an :atom option, very similar to render :xml
+        def render(options = {}, extra_options = {}, &block)
+          if atom = options[:atom]
+            response.content_type ||= Mime::ATOM
+            render_for_text(atom.respond_to?(:to_atom) ? atom.to_atom.to_xml : atom.to_xml, options[:status])
+          else
+            super
+          end
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Restfulie
+  module Server
+    module ActionController
+      class ParamsParser
+        # This class is just a proxy for the extension point offered by ActionController::Base
+        @@param_parsers = ::ActionController::Base.param_parsers
+
+        ## 
+        # :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)
+          @@param_parsers[Mime::Type.lookup(content_type)] = representation.method(:to_hash).to_proc
+        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)
+          @@param_parsers.delete(Mime::Type.lookup(content_type))
+        end
+      end
+    end
+  end
+end
+
+# 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
+      else
+        if env["CONTENT_LENGTH"] && (env["CONTENT_LENGTH"] != "0")
+          return [415, {'Content-Type' => 'text/html'}, "<html><body><h1>415 Unsupported Media Type</h1></body></html>"]
+        end
+      end
+    rescue
+      return [400, {'Content-Type' => 'text/html'}, "<html><body><h1>400 Bad Request</h1></body></html>"]
+    end
+
+    @app.call(env)
+  end
+end
+

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

@@ -0,0 +1,39 @@
+module Restfulie::Server::ActionController
+  class RestfulResponder < ActionController::Responder
+    
+    def to_format
+      return if do_http_cache? && do_http_cache!
+      super
+    end
+      
+  protected
+    def do_http_cache!
+      timestamp = resources.flatten.map do |resource|
+        (resource.updated_at || Time.now).utc if resource.respond_to?(:updated_at)
+      end.compact.max
+
+      controller.response.last_modified = timestamp if timestamp
+      set_public_cache_control!
+
+      head :not_modified if fresh = request.fresh?(controller.response)
+      fresh
+    end
+
+    def do_http_cache?
+      get? && @http_cache != false && ActionController::Base.perform_caching &&
+        !new_record? && controller.response.last_modified.nil?
+    end
+
+    def new_record?
+      resource.respond_to?(:new_record?) && resource.new_record?
+    end
+    
+    def set_public_cache_control!
+      cache_control = response.headers["Cache-Control"].split(",").map {|k| k.strip }
+      cache_control.delete("private")
+      cache_control.delete("no-cache")
+      cache_control << "public"
+      response.headers["Cache-Control"] = cache_control.join(', ')
+    end
+  end
+end

data/lib/restfulie/server/action_controller/routing/restful_route.rb

@@ -0,0 +1,14 @@
+module Restfulie::Server::ActionController::Routing::Route
+
+  def self.included(base)
+    #base.alias_method_chain :extract_request_environment, :host
+  end
+
+  #def extract_request_environment_with_host(request)
+    #env = extract_request_environment_without_host(request)
+    #env.merge :host => request.host,
+      #:domain => request.domain, :subdomain => request.subdomains.first
+  #end
+  
+end
+

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

@@ -0,0 +1,12 @@
+module Restfulie::Server::ActionController::Routing#:nodoc:
+end
+
+require 'restfulie/server/action_controller/routing/restful_route'
+
+ActionController::Routing::RouteSet.send :include,
+  Restfulie::Server::ActionController::Routing::Route
+
+ActionController::Routing::Route.send :include,
+  Restfulie::Server::ActionController::Routing::Route
+
+

data/lib/restfulie/server/action_controller.rb

@@ -0,0 +1,15 @@
+module Restfulie::Server::ActionController#:nodoc:
+
+  if defined?(::ActionController) || defined?(::ApplicationController)
+
+    %w(
+      params_parser
+      restful_responder
+      base
+      routing
+    ).each do |file|
+      autoload file.camelize.to_sym, "restfulie/server/action_controller/#{file}"
+    end
+
+  end
+end

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

@@ -0,0 +1,45 @@
+module Restfulie::Server::ActionView::Helpers
+  # Load a partial template to execute in describe
+  #
+  # For example:
+  #
+  # Passing the current context to partial in template:
+  #
+  #  describe_member(@album) do |member, album|
+  #    partial('member', binding)
+  #  end
+  #
+  # in partial:
+  #
+  #  member.links << link(:rel => :artistis, :href => album_artists_url(album))
+  #
+  # Or passing local variables assing
+  #  
+  #  descirbe_collection(@albums) do |collection|
+  #    collection.describe_members do |member, album|
+  #      partial('member', :locals => {:member => member, :album => album})
+  #    end
+  #  end
+  #
+  def partial(partial_path, caller_binding = nil)
+    template = _pick_partial_template(partial_path)
+
+    # Create a context to assing variables
+    if caller_binding.kind_of?(Hash)
+      Proc.new do
+        extend Restfulie::Common::Builder::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
+      eval(template.source, caller_binding, template.path)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Restfulie::Server::ActionView::TemplateHandlers
+  
+  class Tokamak < ActionView::TemplateHandler
+    include ActionView::TemplateHandlers::Compilable
+      
+    # TODO: Implement error for code not return builder
+    def compile(template)
+      "extend Restfulie::Common::Builder::Helpers; " +
+      "extend Restfulie::Server::ActionView::Helpers; " +
+      "code_block = lambda { #{template.source} };" + 
+      "builder = code_block.call; " +
+      "builder.to_atom "
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Restfulie::Server::ActionView::TemplateHandlers #:nodoc:
+end
+
+require 'restfulie/server/action_view/template_handlers/tokamak'
+
+if defined? ::ActionView::Template and ::ActionView::Template.respond_to? :register_template_handler
+  ::ActionView::Template
+else
+  ::ActionView::Base
+end.register_template_handler(:tokamak, Restfulie::Server::ActionView::TemplateHandlers::Tokamak)
+
+::ActionController::Base.exempt_from_layout :tokamak if defined? ::ActionController::Base
+

data/lib/restfulie/server/action_view.rb

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

data/lib/restfulie/server/configuration.rb

@@ -0,0 +1,21 @@
+module Restfulie::Server::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
+

data/lib/restfulie/server/core_ext/array.rb

@@ -0,0 +1,45 @@
+# Introspective methods to assist in the conversion of collections in other formats.
+class Array
+  def to_atom(options={}, &block)
+    raise "Not all elements respond to to_atom" unless all? { |e| e.respond_to? :to_atom }
+    options = options.dup
+    
+    if options.delete :only_self_link
+      options[:skip_associations_links] = true
+      options[:skip_attributes]         = true      
+    end
+    
+    Atom::Feed.new do |feed|
+      # TODO: Define better feed attributes
+      # Array#to_s can return a very long string
+      feed.title   = "Collection of #{map {|i| i.class.name }.uniq.to_sentence}"
+      # TODO: this id does not comply with Rest standards yet
+      feed.id      = hash
+      feed.updated = updated_at
+    
+      each do |element|
+        feed.entries << element.to_atom(options)
+      end
+      
+      yield feed if block_given?
+    end
+  end
+  
+  # Return max update date for items in collection, for it uses the updated_at of items.
+  # 
+  #==Example:
+  #
+  # Find max updated at in ActiveRecord objects 
+  #
+  #   albums = Albums.find(:all)
+  #   albums.updated_at
+  # 
+  # Using a custom field to check the max date
+  #
+  #   albums = Albums.find(:all)
+  #   albums.updated_at(:created_at)
+  #
+  def updated_at(field = :updated_at)
+    map { |item| item.send(field) if item.respond_to?(field) }.compact.max || Time.now
+  end
+end

data/lib/restfulie/server/core_ext.rb

@@ -0,0 +1 @@
+require 'restfulie/server/core_ext/array'

data/lib/restfulie/server/restfulie_controller.rb

@@ -1,25 +1,9 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-
 module Restfulie
   
   module Server
   
     # Controller which adds default CRUD + search + other operations.
+    # TODO: move these actions to controller/base.rb (maybe using InheritedResources, maybe not)
     module Controller
     
       # creates a model based on the request media-type extracted from its content-type

data/lib/restfulie/server.rb

@@ -0,0 +1,15 @@
+require 'restfulie/common'
+require 'responders_backport'
+
+module Restfulie::Server; end
+
+%w(
+  configuration
+  action_controller
+  action_view
+  core_ext
+  restfulie_controller
+).each do |file|
+  require "restfulie/server/#{file}"
+end
+