actionpack 0.9.0

data/lib/action_controller/session/active_record_store.rb

@@ -0,0 +1,72 @@
+begin
+
+require 'active_record'
+require 'cgi'
+require 'cgi/session'
+
+# Contributed by Tim Bates
+class CGI
+  class Session
+    # ActiveRecord database based session storage class.
+    #
+    # Implements session storage in a database using the ActiveRecord ORM library. Assumes that the database
+    # has a table called +sessions+ with columns +id+ (numeric, primary key), +sessid+ and +data+ (text).
+    # The session data is stored in the +data+ column in YAML format; the user is responsible for ensuring that
+    # only data that can be YAMLized is stored in the session.
+    class ActiveRecordStore
+      # The ActiveRecord class which corresponds to the database table.
+      class Session < ActiveRecord::Base
+        serialize :data
+        # Isn't this class definition beautiful?
+      end
+
+      # Create a new ActiveRecordStore instance. This constructor is used internally by CGI::Session.
+      # The user does not generally need to call it directly.
+      #
+      # +session+ is the session for which this instance is being created.
+      #
+      # +option+ is currently ignored as no options are recognized.
+      #
+      # This session's ActiveRecord database row will be created if it does not exist, or opened if it does.
+      def initialize(session, option=nil)
+        @session = Session.find_first(["sessid = '%s'", session.session_id])
+        if @session
+          @data = @session.data
+        else
+          @session = Session.new("sessid" => session.session_id, "data" => {})
+        end
+      end
+
+      # Update and close the session's ActiveRecord object.
+      def close
+        return unless @session
+        update
+        @session = nil
+      end
+
+      # Close and destroy the session's ActiveRecord object.
+      def delete
+        return unless @session
+        @session.destroy
+        @session = nil
+      end
+
+      # Restore session state from the session's ActiveRecord object.
+      def restore
+        return unless @session
+        @data = @session.data
+      end
+
+      # Save session state in the session's ActiveRecord object.
+      def update
+        return unless @session
+        @session.data = @data
+        @session.save
+      end
+    end #ActiveRecordStore
+  end #Session
+end #CGI
+
+rescue LoadError
+  # Couldn't load Active Record, so don't make this store available
+end

data/lib/action_controller/session/drb_server.rb

@@ -0,0 +1,9 @@
+#!/usr/local/bin/ruby -w
+                                                                                
+# This is a really simple session storage daemon, basically just a hash, 
+# which is enabled for DRb access.
+                                                                                
+require 'drb'
+
+DRb.start_service('druby://127.0.0.1:9192', Hash.new)
+DRb.thread.join

data/lib/action_controller/session/drb_store.rb

@@ -0,0 +1,31 @@
+require 'cgi'
+require 'cgi/session'
+require 'drb'
+ 
+class CGI #:nodoc:all
+  class Session
+    class DRbStore
+      @@session_data = DRbObject.new(nil, 'druby://localhost:9192')
+ 
+      def initialize(session, option=nil)
+        @session_id = session.session_id
+      end
+ 
+      def restore
+        @h = @@session_data[@session_id] || {}
+      end
+ 
+      def update
+        @@session_data[@session_id] = @h
+      end
+ 
+      def close
+        update
+      end
+ 
+      def delete
+        @@session_data.delete(@session_id)
+      end
+    end
+  end
+end

data/lib/action_controller/support/class_attribute_accessors.rb

@@ -0,0 +1,57 @@
+# Extends the class object with class and instance accessors for class attributes, 
+# just like the native attr* accessors for instance attributes.
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym.id2name}
+          @@#{sym.id2name} = nil
+        end
+        
+        def self.#{sym.id2name}
+          @@#{sym}
+        end
+
+        def #{sym.id2name}
+          @@#{sym}
+        end
+
+        def call_#{sym.id2name}
+          case @@#{sym.id2name}
+            when Symbol then send(@@#{sym})
+            when Proc   then @@#{sym}.call(self)
+            when String then @@#{sym}
+            else nil
+          end
+        end
+      EOS
+    end
+  end
+  
+  def cattr_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym.id2name}
+          @@#{sym.id2name} = nil
+        end
+        
+        def self.#{sym.id2name}=(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def self.set_#{sym.id2name}(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def #{sym.id2name}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+  
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/action_controller/support/class_inheritable_attributes.rb

@@ -0,0 +1,37 @@
+# Allows attributes to be shared within an inheritance hierarchy, but where each descentent gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+module ClassInheritableAttributes # :nodoc:
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods # :nodoc:
+    @@classes ||= {}
+    
+    def inheritable_attributes
+      @@classes[self] ||= {}
+    end
+    
+    def write_inheritable_attribute(key, value)
+      inheritable_attributes[key] = value
+    end
+    
+    def write_inheritable_array(key, elements)
+      write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+      write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+    end
+
+    def read_inheritable_attribute(key)
+      inheritable_attributes[key]
+    end
+    
+    private 
+      def inherited(child)
+        @@classes[child] = inheritable_attributes.dup
+      end
+   
+  end
+end

data/lib/action_controller/support/clean_logger.rb

@@ -0,0 +1,10 @@
+require 'logger'
+
+class Logger #:nodoc:
+  private
+    remove_const "Format"
+    Format = "%s\n"
+    def format_message(severity, timestamp, msg, progname)
+      Format % [msg]
+    end
+end

data/lib/action_controller/support/cookie_performance_fix.rb

@@ -0,0 +1,121 @@
+CGI.module_eval { remove_const "Cookie" }
+
+class CGI #:nodoc:
+  # This is a cookie class that fixes the performance problems with the default one that ships with 1.8.1 and below.
+  # It replaces the inheritance on SimpleDelegator with DelegateClass(Array) following the suggestion from Matz on
+  # http://groups.google.com/groups?th=e3a4e68ba042f842&seekm=c3sioe%241qvm%241%40news.cybercity.dk#link14
+  class Cookie < DelegateClass(Array)
+    # Create a new CGI::Cookie object.
+    #
+    # The contents of the cookie can be specified as a +name+ and one
+    # or more +value+ arguments.  Alternatively, the contents can
+    # be specified as a single hash argument.  The possible keywords of
+    # this hash are as follows:
+    #
+    # name:: the name of the cookie.  Required.
+    # value:: the cookie's value or list of values.
+    # path:: the path for which this cookie applies.  Defaults to the
+    #        base directory of the CGI script.
+    # domain:: the domain for which this cookie applies.
+    # expires:: the time at which this cookie expires, as a +Time+ object.
+    # secure:: whether this cookie is a secure cookie or not (default to
+    #          false).  Secure cookies are only transmitted to HTTPS 
+    #          servers.
+    #
+    # These keywords correspond to attributes of the cookie object.
+    def initialize(name = "", *value)
+      options = if name.kind_of?(String)
+                  { "name" => name, "value" => value }
+                else
+                  name
+                end
+      unless options.has_key?("name")
+        raise ArgumentError, "`name' required"
+      end
+
+      @name = options["name"]
+      @value = Array(options["value"])
+      # simple support for IE
+      if options["path"]
+        @path = options["path"]
+      else
+        %r|^(.*/)|.match(ENV["SCRIPT_NAME"])
+        @path = ($1 or "")
+      end
+      @domain = options["domain"]
+      @expires = options["expires"]
+      @secure = options["secure"] == true ? true : false
+
+      super(@value)
+    end
+
+    def __setobj__(obj)
+      @_dc_obj = obj
+    end
+
+    attr_accessor("name", "value", "path", "domain", "expires")
+    attr_reader("secure")
+
+    # Set whether the Cookie is a secure cookie or not.
+    #
+    # +val+ must be a boolean.
+    def secure=(val)
+      @secure = val if val == true or val == false
+      @secure
+    end
+
+    # Convert the Cookie to its string representation.
+    def to_s
+      buf = ""
+      buf += @name + '='
+
+      if @value.kind_of?(String)
+        buf += CGI::escape(@value)
+      else
+        buf += @value.collect{|v| CGI::escape(v) }.join("&")
+      end
+
+      if @domain
+        buf += '; domain=' + @domain
+      end
+
+      if @path
+        buf += '; path=' + @path
+      end
+
+      if @expires
+        buf += '; expires=' + CGI::rfc1123_date(@expires)
+      end
+
+      if @secure == true
+        buf += '; secure'
+      end
+
+      buf
+    end
+
+    # Parse a raw cookie string into a hash of cookie-name=>Cookie
+    # pairs.
+    #
+    #   cookies = CGI::Cookie::parse("raw_cookie_string")
+    #     # { "name1" => cookie1, "name2" => cookie2, ... }
+    #
+    def self.parse(raw_cookie)
+      cookies = Hash.new([])
+      return cookies unless raw_cookie
+
+      raw_cookie.split(/; /).each do |pairs|
+        name, values = pairs.split('=',2)
+        next unless name and values
+        name = CGI::unescape(name)
+        values ||= ""
+        values = values.split('&').collect{|v| CGI::unescape(v) }
+        unless cookies.has_key?(name)
+          cookies[name] = new({ "name" => name, "value" => values })
+        end
+      end
+
+      cookies
+    end
+  end # class Cookie
+end

data/lib/action_controller/support/inflector.rb

@@ -0,0 +1,70 @@
+# The Inflector transforms words from singular to plural, class names to table names, modulized class names to ones without,
+# and class names to foreign keys.
+module Inflector 
+  extend self
+
+  def pluralize(word)
+    result = word.dup
+    plural_rules.each do |(rule, replacement)|
+      break if result.gsub!(rule, replacement)
+    end
+    return result
+  end
+
+  def singularize(word)
+    result = word.dup
+    singular_rules.each do |(rule, replacement)|
+      break if result.gsub!(rule, replacement)
+    end
+    return result
+  end
+
+  def camelize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.gsub(/(^|_)(.)/){$2.upcase}
+  end
+  
+  def underscore(camel_cased_word)
+    camel_cased_word.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+  end
+
+  def demodulize(class_name_in_module)
+    class_name_in_module.gsub(/^.*::/, '')
+  end
+
+  def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+    Inflector.underscore(Inflector.demodulize(class_name)) + 
+      (separate_class_name_and_id_with_underscore ? "_id" : "id")
+  end
+  
+  private
+    def plural_rules #:doc:
+      [
+        [/(x|ch|ss)$/, '\1es'],               # search, switch, fix, box, process, address
+        [/([^aeiouy]|qu)y$/, '\1ies'],        # query, ability, agency
+        [/(?:([^f])fe|([lr])f)$/, '\1\2ves'], # half, safe, wife
+        [/sis$/, 'ses'],                      # basis, diagnosis
+        [/([ti])um$/, '\1a'],                 # datum, medium
+        [/person$/, 'people'],                # person, salesperson
+        [/man$/, 'men'],                      # man, woman, spokesman
+        [/child$/, 'children'],               # child
+        [/s$/, 's'],                          # no change (compatibility)
+        [/$/, 's']
+      ]
+    end
+
+    def singular_rules #:doc:
+      [
+          [/(x|ch|ss)es$/, '\1'],
+          [/([^aeiouy]|qu)ies$/, '\1y'],
+          [/([lr])ves$/, '\1f'],
+          [/([^f])ves$/, '\1fe'],
+          [/(analy|ba|diagno|parenthe|progno|synop|the)ses$/, '\1sis'],
+          [/([ti])a$/, '\1um'],
+          [/people$/, 'person'],
+          [/men$/, 'man'],
+          [/status$/, 'status'],
+          [/children$/, 'child'],
+          [/s$/, '']
+        ]
+    end
+end

data/lib/action_controller/templates/rescues/_request_and_response.rhtml

@@ -0,0 +1,28 @@
+<%
+  base_dir = File.expand_path(File.dirname(__FILE__))
+    
+  request_parameters_without_action = @request.parameters.clone
+  request_parameters_without_action.delete("action")
+  request_parameters_without_action.delete("controller")
+  
+  request_dump  = request_parameters_without_action.inspect.gsub(/,/, ",\n")
+  session_dump  = @request.session.instance_variable_get("@data").inspect.gsub(/,/, ",\n")
+  response_dump = @response.inspect.gsub(/,/, ",\n")
+
+  template_assigns = @response.template.instance_variable_get("@assigns")
+  %w( response exception template session request template_root template_class url ignore_missing_templates logger cookies headers params ).each { |t| template_assigns.delete(t) }
+  template_dump = template_assigns.inspect.gsub(/,/, ",\n")
+%>
+
+<h2 style="margin-top: 30px">Request</h2>
+<p><b>Parameters</b>: <%=h request_dump == "{}" ? "None" : request_dump %></p>
+
+<p><a href="#" onclick="document.getElementById('session_dump').style.display='block'; return false;">Show session dump</a></p>
+<div id="session_dump" style="display:none"><%= debug(@request.session.instance_variable_get("@data")) %></div>
+
+
+<h2 style="margin-top: 30px">Response</h2>
+<b>Headers</b>: <%=h @response.headers.inspect.gsub(/,/, ",\n") %><br/>
+
+<p><a href="#" onclick="document.getElementById('template_dump').style.display='block'; return false;">Show template parameters</a></p>
+<div id="template_dump" style="display:none"><%= debug(template_assigns) %></div>

data/lib/action_controller/templates/rescues/diagnostics.rhtml

@@ -0,0 +1,22 @@
+<%
+  base_dir = File.expand_path(File.dirname(__FILE__))
+    
+  clean_backtrace = @exception.backtrace.collect { |line| line.gsub(base_dir, "").gsub("/../config/environments/../../", "") }
+  app_trace       = clean_backtrace.reject { |line| line[0..6] == "vendor/" || line.include?("dispatch.cgi") }
+  framework_trace = clean_backtrace - app_trace
+%>
+
+<h1>
+  <%=h @exception.class.to_s %> in
+  <%=h @request.parameters["controller"].capitalize %>#<%=h @request.parameters["action"] %>
+</h1>
+<p><%=h @exception.message %></p>
+
+<% unless app_trace.empty? %><pre><code><%=h app_trace.collect { |line| line.gsub("/../", "") }.join("\n") %></code></pre><% end %>
+
+<% unless framework_trace.empty? %>
+  <a href="#" onclick="document.getElementById('framework_trace').style.display='block'; return false;">Show framework trace</a>
+  <pre id="framework_trace" style="display:none"><code><%=h framework_trace.join("\n") %></code></pre>
+<% end %>
+
+<%= render_file(@rescues_path + "/_request_and_response.rhtml", false) %>