raw 0.49.0

data/lib/raw/controller/publishable.rb

@@ -0,0 +1,160 @@
+require "facets/more/ann"
+
+require "raw/render"
+require "raw/render/caching"
+require "raw/context/flash"
+require "raw/helper"
+require "raw/helper/cookie"
+require "raw/compiler"
+require "raw/compiler/filter/template"
+require "raw/util/encode_uri"
+require "raw/util/markup"
+
+module Raw
+
+# Include this Mixin to a class to make objects of this class
+# publishable, ie accessible through a standard web (REST) 
+# interface.
+
+module Publishable
+  def self.included(base)
+    super
+    base.send(:include, Render)
+    base.send(:include, Flashing)
+    base.send(:include, Caching)
+    base.send(:include, Helpers)
+    base.helper(EncodeURI)
+    base.helper(CookieHelper)
+    base.helper(Markup)
+  end
+
+  # Use the method_missing hook to compile the actions
+  # for this controller.
+
+  def method_missing(action, *args)
+    if Context.current.application.compiler.compile(self.class, action)
+      send(action, *args)
+    else
+      super
+    end
+  end
+  
+  class_extension do
+
+    # The path where this controller is mounted.
+    
+    attr_accessor :mount_path
+  
+    # Return the 'action' methods for this Object. Some 
+    # dangerous methods from ancestors are removed. All private 
+    # methods are ignored.
+    #--
+    # gmosx, TODO: We should optimize this method.
+    #++
+
+    def action_methods
+      public_instance_methods - Controller.public_instance_methods      
+    end
+    alias_method :actions, :action_methods
+
+    # Check if the controller responds to this action.
+    
+    def action?(action)
+      action_methods.include?(action.to_s)
+    end
+    alias_method :respond_to_action?, :action?  
+
+    # Check if the a template for this action and format exists.
+    # Returns a valid path or nil.
+    
+    def template?(action, format)
+      # Allow for template override using the :template annotation
+      #
+      # class MyController
+      #   def myaction
+      #   end
+      #   ann :myaction, :template => :another_template
+      # end
+      
+      template = ann(action, :template) || action
+
+      template = template.to_s.gsub(/__/, "/")
+      
+      for dir in ann(:self, :template_dir_stack)
+        name = "#{dir}/#{template}".squeeze("/")
+        
+        # attempt to find a template of the form:
+        # dir/action.xhtml
+
+        path = "#{name}.#{format.template_extension}"
+        return path if File.exist?(path)
+      
+        # attempt to find a template of the form:
+        # dir/action/index.xhtml
+
+        path = "#{name}/index.#{format.template_extension}"
+        return path if File.exist?(path) 
+      end
+      
+      return nil
+    end
+    alias_method :has_template?, :template?
+    alias_method :template_path, :template?
+      
+    # Check if this action or template exists.
+      
+    def action_or_template?(action, format)
+      action?(action) or template?(action, format)
+    end
+    alias_method :respond_to_action_or_template?, :action_or_template?
+
+    # Aliases an action
+    #--
+    # gmosx, FIXME: better implementation needed.
+    # gmosx, FIXME: copy all annotations.
+    #++
+
+    def alias_action(new, old)
+      alias_method new, old
+      ann new, :template => old        
+    end
+        
+    # Override this method to customize the template_dir_stack.
+    # Typically used in controllers defined in reusable Parts.
+    # Call super to include the parent class's customizations.
+    # Implements some form of template root inheritance, 
+    # thus allowing for more reusable controllers. Ie you can
+    # 'extend' a controller, and only override the templates
+    # you want to change. The compiler will traverse the 
+    # template dir stack and use the templates from parent
+    # controllers if they are not overriden.
+    #
+    # def self.setup_template_dir_stack(stack)
+    #   super
+    #   stack << "custom/route/#{self.mount_path}"
+    #   stack << "another/route"
+    # end  
+    
+    def setup_template_dir_stack(path)
+    end
+
+    # This callback is called when this controller is mounted.
+        
+    def mount_at(path)
+      @mount_path = path
+
+      # Setup the template_dir_stack.
+
+      stack = []
+      stack << File.join(Template.root_dir, path).gsub(/\/$/, "")
+      self.setup_template_dir_stack(stack)
+      stack << File.join(Nitro.proto_path, "template", path).gsub(/\/$/, "")
+      ann(:self, :template_dir_stack => stack)
+    end
+    alias_method :mount, :mount_at
+
+  end # class_extension
+  
+end
+
+end

data/lib/raw/dispatcher.rb

@@ -0,0 +1,209 @@
+require "facets/core/module/ancestor"
+
+require "raw/dispatcher/router"
+require "raw/dispatcher/mounter"
+require "raw/dispatcher/format"
+
+module Raw
+
+# The Dispatcher manages a set of controllers. It selects the
+# appropriate Controller and action to handle the given 
+# request.
+#
+# This dispatcher intelligently handles RESTful uris according
+# to the following scheme:
+#
+# GET    /links             GET  /links/index     Link::Controller#index
+# POST   /links             POST /links/create    Link::Controller#create  
+# GET    /links;new         GET  /links/new       Link::Controller#new
+# GET    /links/1                                 Link::Controller#view(1)
+# GET    /links/1;edit      GET  /links/edit/1    Link::Controller#edit(1)
+# PUT    /links/1           POST /links/update/1  Link::Controller#update
+# DELETE /links/1           GET  /links/delete/1  Link::Controller#delete(1)
+# GET    /links/index.xml                         Link::Controller#index # Atom
+# GET    /links/index.json                        Link::Controller#index # JSON
+#
+# The default actions for the various methods are:
+#
+#    GET: index
+#   POST: create
+#    PUT: update
+# DELETE: delete
+
+class Dispatcher
+
+  # The (optional) router.
+  
+  attr_accessor :router
+  
+  # The hash that maps mount paths to controllers.  
+
+  attr_accessor :controllers
+
+  # The representation formats this dispatcher understands.
+  
+  attr_accessor :formats
+  
+  # Initialize the dispatcher.
+  
+  def initialize(controller_or_map = nil)
+    @controllers = {} 
+    @formats = Nitro::STANDARD_FORMATS.dup
+    
+    if controller_or_map.is_a?(Class)
+      mount("/" => controller_or_map)
+    elsif controller_or_map.is_a?(Hash)
+      mount(controller_or_map)
+    end 
+  end
+
+  # Mounts a map of controllers.
+  
+  def mount(map)
+    for path, controller in map
+      self[path] = controller
+    end
+  end
+
+  # Return the controller for the given mount path.
+  
+  def [](path = "/")
+    @controllers[path]
+  end
+
+  # Mount a controller to the given mount path.
+    
+  def []=(path, controller)
+    controller = resolve_controller(controller)
+
+    # Customize the class for mounting at the given path.
+    controller.mount_at(path) if controller.respond_to? :mount_at
+    
+    # Call the mounted callback to allow for post mount
+    # initialization.
+    controller.mounted(path) if controller.respond_to? :mounted
+
+    @controllers[path] = controller
+  end
+
+  # Dispatch a request. Calls the lower level dispatch method.
+  
+  def dispatch_request(request)  
+    dispatch(request.uri, request.method)
+  end
+  alias_method :dispatch_context, :dispatch_request
+
+  # Dispatch a path given the request method. This method 
+  # handles fully resolved paths (containing an extension that 
+  # denotes the expected content type).
+  #
+  # This method automatically handles 'nice' (seo friendly, elegant)
+  # parameters, ie:
+  #
+  # /links/view/1
+  #
+  # instead of
+  #
+  # /links/view?oid=1
+  #
+  # === Output
+  #
+  # controller, action, query_string, nice_params, extension
+  #
+  #--
+  # Lower level, useful for testing.
+  #++
+  
+  def dispatch(uri, method = :get)
+    # Extract the query string.
+    
+    path, query = uri.split("?", 2)
+
+    # Try to route the path.
+    
+    path = @router.route(path) if @router
+
+    # The characters after the last '.' in the path form the 
+    # extension that itself represents the expected response
+    # content type.
+    
+    ext = File.extname(path)[1..-1] || "html" 
+
+    # The resource representation format for this request.
+    
+    unless format = Context.current.format = @formats.by_extension[ext]
+      raise ActionError.new("Cannot respond to '#{path}' using the '#{ext}' format representation.") 
+    end
+    
+    # Remove the extension from the path.
+    
+    path = path.gsub(/\.(.*)$/, '')
+    
+    # Try to extract the controller from the path (that may also
+    # include 'nice' parameters). This algorithm tries to find 
+    # the bigest substring of the path that represents a mount 
+    # path for a controller.
+
+    key = path.dup    
+
+    while (controller = @controllers[key]).nil?
+      key = key[%r{^(/.+)/.+$}, 1] || '/'
+    end
+
+    # Try to extract the controller from the path. This 
+    # algorithm tries to find the bigest substring of the path 
+    # that represents an action of this controller. 
+    #
+    # The algorithm respects action name conventions, ie
+    # simple/sub/action maps to simple__sub__action.
+
+    action = key = path.sub(%r{^#{key}}, '').gsub(%r{^/}, '').gsub(%r{/}, '__')
+
+    while (!action.blank?) and !controller.action_or_template?(action, format)
+      action = action[%r{^(.+)__.+$}, 1]
+    end
+
+    # Extract the 'nice' parameters.
+    
+    params = key.sub(%r{^#{action}}, '').gsub(/^__/, '').split('__')
+    
+    # Do we have an action?
+    
+    if action.blank?
+      # Try to use a standard action for this http method.
+
+      case method
+        when :get
+          action = "index"
+          
+        when :post
+          action = "create"
+            
+        when :delete
+          action = "delete"
+          
+        when :put
+          action = "update"
+      end
+      
+      unless controller.action_or_template?(action, format)
+        raise ActionError.new("Cannot respond to '#{path}' using '#{controller}'") 
+      end
+    end
+
+    return controller, "#{action}___super", query, params, ext
+  end
+
+private
+
+  def resolve_controller(controller)
+    unless controller.ancestor?(Controller) or controller.ancestor?(Publishable)
+      controller.send(:include, Publishable)
+    end
+
+    return controller
+  end
+
+end
+
+end

data/lib/raw/dispatcher/format.rb

@@ -0,0 +1,108 @@
+module Raw
+
+# A REST Resource Representation format.
+
+class Format
+
+  # The name of this format.
+  
+  attr_accessor :name
+  
+  # The resource content type. Typically the resource MIME type 
+  # is used.
+  
+  attr_accessor :content_type
+  alias_method :mime_type, :content_type
+
+  # The default resource extension.
+  
+  attr_accessor :extension
+  
+  # The default template extension.
+  
+  attr_accessor :template_extension
+  
+  def to_s
+    @name
+  end
+
+  # Apply filters to the template source. The original template
+  # representation must be transformed to executable Ruby code
+  # at the end.
+  
+  def filter_template(source)
+    return source
+  end
+
+  # This callback is called before the action is executed with
+  # this format.
+  
+  def before_action(controller, context)
+  end
+
+  # This callback is called after the action is executed with
+  # this format.
+    
+  def after_action(controller, context)
+  end
+  
+end
+
+# A Format Manager. Provides useful methods for fast Format
+# lookup.
+
+class FormatManager
+  # Formats indexed by name.
+
+  attr_accessor :by_name
+
+  # Formats indexed by mime type.
+
+  attr_accessor :by_mime_type
+
+  # Formats indexed by extension.
+  
+  attr_accessor :by_extension  
+    
+  def initialize(*formats)
+    @by_name = {}
+    @by_mime_type = {}
+    @by_extension = {}
+    
+    for format in formats.flatten
+      put(format)
+    end
+  end
+
+  # Add a new format to the manager.
+    
+  def put(format)
+    if format.is_a? Class
+      format = format.new
+    end
+    
+    @by_name[format.name] = format          
+    @by_mime_type[format.mime_type] = format          
+    @by_extension[format.extension] = format          
+  end
+  alias_method :<<, :put
+  
+  # Lookup a format by name.
+  
+  def [](name)
+    @by_name[name]
+  end
+  
+end
+
+require "raw/dispatcher/format/html"
+require "raw/dispatcher/format/atom"
+require "raw/dispatcher/format/rss"
+require "raw/dispatcher/format/json"
+require "raw/dispatcher/format/xoxo"
+
+STANDARD_FORMATS = FormatManager.new(
+  HTMLFormat, ATOMFormat, RSSFormat, JSONFormat, XOXOFormat
+)
+
+end