raw 0.49.0

data/lib/raw/dispatcher/format/atom.rb

@@ -0,0 +1,31 @@
+require "facets/more/xoxo"
+
+require "raw/dispatcher/format"
+
+module Raw
+  
+class ATOMFormat < Format
+
+  def initialize
+    @name = "atom"
+    @content_type = "application/atom+xml" # "text/xml"
+    @extension = "atom"
+    @template_extension = "atomx"
+  end
+
+  def after_action(controller, context)
+    if controller.out.blank?
+      if model = controller.class.ann(:self, :model)
+        resource = model.to_s.demodulize.underscore
+        if collection = controller.instance_variable_get("@#{resource.plural}")
+          controller.send(:print, XOXO.dump(collection))
+        elsif resource = controller.instance_variable_get("@#{resource}") 
+          controller.send(:print, XOXO.dump(resource))
+        end
+      end
+    end
+  end
+  
+end
+
+end

data/lib/raw/dispatcher/format/html.rb

@@ -0,0 +1,42 @@
+require "raw/dispatcher/format"
+require "raw/compiler/filter/template"
+require "raw/compiler/filter/squeeze"
+require "raw/compiler/filter/markup"
+require "raw/compiler/filter/morph"
+require "raw/compiler/filter/static_include"
+require "raw/compiler/filter/elements"
+require "raw/compiler/filter/cleanup"
+
+module Raw
+  
+class HTMLFormat < Format
+
+  def initialize
+    @name = "html"
+    @content_type = "text/html"
+    @extension = "html"
+    @template_extension = "htmlx"
+    @template_filters = [
+      StaticIncludeFilter.new, 
+      ElementsFilter.new,
+      MorphFilter.new,
+      CleanupFilter.new,
+      MarkupFilter.new,
+#     SqueezeFilter.new,
+      TemplateFilter.new
+    ]
+  end
+
+  def filter_template(source)
+    return if source.blank?
+    
+    for filter in @template_filters
+      source = filter.apply(source)
+    end
+    
+    return source
+  end
+    
+end
+
+end

data/lib/raw/dispatcher/format/json.rb

@@ -0,0 +1,31 @@
+require "facets/more/json"
+
+require "raw/dispatcher/format"
+
+module Raw
+  
+class JSONFormat < Format
+
+  def initialize
+    @name = "json"
+    @content_type = "application/json"
+    @extension = "json"
+    @template_extension = "jsonx"
+  end
+
+  def after_action(controller, context)
+    if controller.out.blank?
+      if model = controller.class.ann(:self, :model)
+        resource = model.to_s.demodulize.underscore
+        if collection = controller.instance_variable_get("@#{resource.plural}")
+          controller.send(:print, collection.to_json)
+        elsif resource = controller.instance_variable_get("@#{resource}") 
+          controller.send(:print, resource.to_json)
+        end
+      end
+    end
+  end
+  
+end
+
+end

data/lib/raw/dispatcher/format/rss.rb

@@ -0,0 +1,33 @@
+require "facets/more/xoxo"
+
+require "raw/dispatcher/format"
+
+module Raw
+  
+class RSSFormat < Format
+
+  def initialize
+    @name = "rss"
+    @content_type = "text/xml"
+    @extension = "xml"
+    @template_extension = "xmlx"
+  end
+
+  def after_action(controller)
+=begin  
+    if controller.out.blank?
+      if model = controller.class.ann(:self, :model)
+        resource = model.to_s.demodulize.underscore
+        if collection = controller.instance_variable_get("@#{resource.plural}")
+          controller.send(:print, XOXO.dump(collection))
+        elsif resource = controller.instance_variable_get("@#{resource}") 
+          controller.send(:print, XOXO.dump(resource))
+        end
+      end
+    end
+=end    
+  end
+  
+end
+
+end

data/lib/raw/dispatcher/format/xoxo.rb

@@ -0,0 +1,31 @@
+require "facets/more/xoxo"
+
+require "raw/dispatcher/format"
+
+module Raw
+  
+class XOXOFormat < Format
+
+  def initialize
+    @name = "xoxo"
+    @content_type = "application/xoxo+xml"
+    @extension = "xoxo"
+    @template_extension = "xoxox"
+  end
+
+  def after_action(controller, context)
+    if controller.out.blank?
+      if model = controller.class.ann(:self, :model)
+        resource = model.to_s.demodulize.underscore
+        if collection = controller.instance_variable_get("@#{resource.plural}")
+          controller.send(:print, XOXO.dump(collection))
+        elsif resource = controller.instance_variable_get("@#{resource}") 
+          controller.send(:print, XOXO.dump(resource))
+        end
+      end
+    end
+  end
+  
+end
+
+end

data/lib/raw/dispatcher/mounter.rb

@@ -0,0 +1,60 @@
+require "raw/dispatcher"
+
+module Raw
+
+class Dispatcher
+
+  # A Helper class used for CherryPy-style publishing. This is 
+  # the prefered way to mount (publish) controllers to 
+  # paths as it automatically defines a controller hierarchy.
+  
+  class Mounter # :nodoc: all
+  
+    def initialize(dispatcher, parent)
+      @dispatcher, @parent = dispatcher, parent
+    end
+    
+    def method_missing(sym, *args)
+      name = sym.to_s
+      if name =~ /=$/
+        name = name.chop
+        if controller = args.first
+          # Store the hierarchical parent of this controller.
+          # Useful for sitemaps etc.
+          controller.ann(:self, :parent => @parent)
+          @dispatcher[path(name)] = controller
+        end
+      else
+        if controller = @dispatcher[path(name)]
+          Mounter.new(@dispatcher, controller)
+        end
+      end
+    end
+    
+    def path(name)
+      "#{@parent.mount_path}/#{name}".squeeze("/")
+    end
+  
+  end
+
+  # An alternative mounting mechanism (CherryPy like). 
+  #
+  # === Example
+  # 
+  # dispatcher.root = RootController
+  # dispatcher.root.users = User::Controller
+  # dispatcher.root.users.comments = User::Comment::Controller
+
+  def root=(controller)
+    self["/"] = resolve_controller(controller)
+  end
+  
+  def root
+    if controller = self["/"]
+      Mounter.new(self, controller)
+    end
+  end
+
+end
+
+end

data/lib/raw/dispatcher/router.rb

@@ -0,0 +1,111 @@
+require "cgi"
+
+module Raw
+
+# Routing (path rewriting) functionality. Due to the power of 
+# Nitro's intelligent dispatching mechanism, routing is almost 
+# never used! It is only needed for really special urls.
+
+module RouterMixin
+
+  # The routing rules.
+
+  attr_accessor :rules
+  
+  # Add a routing rule
+  #
+  # === Examples
+  #
+  # r.add_rule(:match => %r{^~(.*)}, :controller => User::Controller, :action => view, :params => [:name])
+  
+  def add_rule(rule)
+    @rules ||= []
+    @rules << rule
+  end
+  alias_method :<<, :add_rule
+  alias_method :add_route, :add_rule
+        
+  # Generate the transformer string for the match gsub. 
+  
+  def rule_transformer(rule)
+    transformer = "#{rule[:controller].mount_path}/#{rule[:action]}"
+    
+    if params = rule[:params]
+      params.size.times do |i|
+        transformer << "/#{i+1}" 
+      end
+    end
+        
+    return transformer
+  end
+
+  # Convert routes defined with annotations to normal routes.
+  # Typically called after a new Controller is mounted.
+  #
+  # === Example of routing through annotations
+  #
+  # def view_user
+  #   "params:  #{request[:id]} and #{request[:mode]}"
+  # end
+  # ann :view_user, :match => /user_(\d*)_(*?)\.html/, :params => [:id, :mode] 
+
+  def add_rules_from_annotations(controller)
+    for m in controller.action_methods
+      m = m.to_sym
+      if match = controller.ann(m, :match)
+        add_rule(:match => match, :controller => controller, :action => m, :params => controller.ann(m, :params))
+      end
+    end
+  end
+
+  # Try to decode the given path by applying routing rules. If
+  # routing is possible return the transformed path, else return
+  # the input path.
+  
+  def decode_route(path)
+    # Front end server (for example Apache) some times escape 
+    # the uri. REMOVE THIS: unescape in the adapter!!
+    path = CGI.unescape(path)
+
+    for rule in @rules
+      unless transformer = rule[:transformer]
+        transformer = rule[:transformer] = rule_transformer(rule)
+      end
+    
+      if path.gsub!(rule[:match], transformer)
+        Logger.debug "Rewriting '#{path}'." if $DBG
+        break;
+      end
+    end
+    
+    return path
+  end
+  alias_method :route, :decode_route   
+
+  # Encodes a [controller, action, params] tupple into a path.
+  # Returns false if no encoding is possible.
+  
+  def encode_route(controller, action, *params)
+    if rule = @rules.find { |r| (r[:controller] == controller) and (r[:action] == action) }
+      path = rule[:match].source
+
+      (params.size / 2).times do |i|
+        val = params[i + i + 1]
+        path.sub!(/\(.*?\)/, val.to_s)
+      end       
+      
+      return path
+    end
+    
+    return false
+  end
+          
+end
+
+# An abstract router.
+
+class Router
+  include RouterMixin
+end
+
+end

data/lib/raw/errors.rb

@@ -0,0 +1,19 @@
+module Raw
+
+# The base class for all Nitro emmited errors and exceptions. 
+
+class RawError < StandardError
+end
+
+# 4XX class errors (Client errors). Typically rendered when 
+# a valid action cannot be found for a path.
+
+class ActionError < RawError
+end
+
+# 5XX class errors.
+
+class ServerError < RawError
+end
+
+end

data/lib/raw/helper.rb

@@ -0,0 +1,86 @@
+require "facets/core/kernel/constant"
+require "facets/core/string/camelize"
+
+module Raw
+
+# Helpers are standard Ruby modules that contain utility 
+# methods. By using the special 'helper'
+# macro provided by Helpers, the utility methods are
+# included as private methods.
+#
+# The helper also requires the ruby file.
+#
+# === Examples
+#
+# class MyController < Nitro::Controller
+#   helper :xhtml # == include Nitro::XhtmlHelper
+# end
+
+module Helpers
+
+  module Utils
+  
+    #--
+    # gmosx: dont name constant to avoid loop.
+    #++
+    
+    def self.const(mod)
+      return constant(mod)
+    rescue NameError => ex
+      return nil
+    end
+  end
+  
+  def self.append_features(base)
+    super
+    base.module_eval do
+      def self.helper(*modules)
+        for mod in modules
+          
+          # If the mod is a string or symbol, also try to 
+          # auto require the source file.
+          #--
+          # gmosx, FIXME: temp solution, will fix!
+          #++
+          
+          if mod.is_a?(String) or mod.is_a?(Symbol)
+            begin
+              # gmosx: dont interpolate (RDoc fix).
+              require("app/helper/" + mod.to_s)
+            rescue LoadError #do not hide SyntaxError, NameError
+              
+              # you can do helper "foo" to load a module withouth requiring
+              begin
+                require("raw/helper/" + mod.to_s) 
+              rescue LoadError 
+                # Drink it!
+              end
+            end
+          end
+                    
+          unless mod.is_a? Module
+            modname = mod.to_s.camelize
+            # gmosx: check xxxHelper before xxx.
+            mod = Utils.const("#{modname}Helper") || 
+                      Utils.const("Raw::#{modname}Helper") || 
+                      Utils.const(modname) 
+          end
+          
+          # name mismatch
+          
+          unless mod
+            raise "helper #{modname} not found (module not defined), check name"
+          end
+          symbols = mod.instance_methods.collect { |m| m.to_sym }
+          
+          self.send(:include, mod)
+          self.send(:private, *symbols)
+#         self.send(:private, mod.to_s[/[^:]+$/].to_sym)
+        end
+      end
+    end
+  end
+  
+end
+
+end