rq 3.4.0 → 3.5.0

data/rails/vendor/rails/actionpack/lib/action_controller/scaffolding.rb

@@ -1,189 +0,0 @@
-module ActionController
-  module Scaffolding # :nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    # Scaffolding is a way to quickly put an Active Record class online by providing a series of standardized actions
-    # for listing, showing, creating, updating, and destroying objects of the class. These standardized actions come
-    # with both controller logic and default templates that through introspection already know which fields to display
-    # and which input types to use. Example:
-    #
-    #  class WeblogController < ActionController::Base
-    #    scaffold :entry
-    #  end
-    #
-    # This tiny piece of code will add all of the following methods to the controller:
-    #
-    #  class WeblogController < ActionController::Base
-    #    verify :method => :post, :only => [ :destroy, :create, :update ],
-    #           :redirect_to => { :action => :list }
-    #
-    #    def index
-    #      list
-    #    end
-    #
-    #    def list
-    #      @entries = Entry.find(:all)
-    #      render_scaffold "list"
-    #    end
-    #
-    #    def show
-    #      @entry = Entry.find(params[:id])
-    #      render_scaffold
-    #    end
-    #
-    #    def destroy
-    #      Entry.find(params[:id]).destroy
-    #      redirect_to :action => "list"
-    #    end
-    #
-    #    def new
-    #      @entry = Entry.new
-    #      render_scaffold
-    #    end
-    #
-    #    def create
-    #      @entry = Entry.new(params[:entry])
-    #      if @entry.save
-    #        flash[:notice] = "Entry was successfully created"
-    #        redirect_to :action => "list"
-    #      else
-    #        render_scaffold('new')
-    #      end
-    #    end
-    #
-    #    def edit
-    #      @entry = Entry.find(params[:id])
-    #      render_scaffold
-    #    end
-    #
-    #    def update
-    #      @entry = Entry.find(params[:id])
-    #      @entry.attributes = params[:entry]
-    #
-    #      if @entry.save
-    #        flash[:notice] = "Entry was successfully updated"
-    #        redirect_to :action => "show", :id => @entry
-    #      else
-    #        render_scaffold('edit')
-    #      end
-    #    end
-    #  end
-    #
-    # The <tt>render_scaffold</tt> method will first check to see if you've made your own template (like "weblog/show.rhtml" for
-    # the show action) and if not, then render the generic template for that action. This gives you the possibility of using the
-    # scaffold while you're building your specific application. Start out with a totally generic setup, then replace one template
-    # and one action at a time while relying on the rest of the scaffolded templates and actions.
-    module ClassMethods
-      # Adds a swath of generic CRUD actions to the controller. The +model_id+ is automatically converted into a class name unless
-      # one is specifically provide through <tt>options[:class_name]</tt>. So <tt>scaffold :post</tt> would use Post as the class
-      # and @post/@posts for the instance variables.
-      #
-      # It's possible to use more than one scaffold in a single controller by specifying <tt>options[:suffix] = true</tt>. This will
-      # make <tt>scaffold :post, :suffix => true</tt> use method names like list_post, show_post, and create_post
-      # instead of just list, show, and post. If suffix is used, then no index method is added.
-      def scaffold(model_id, options = {})
-        options.assert_valid_keys(:class_name, :suffix)
-
-        singular_name = model_id.to_s
-        class_name    = options[:class_name] || singular_name.camelize
-        plural_name   = singular_name.pluralize
-        suffix        = options[:suffix] ? "_#{singular_name}" : ""
-
-        unless options[:suffix]
-          module_eval <<-"end_eval", __FILE__, __LINE__
-            def index
-              list
-            end
-          end_eval
-        end
-
-        module_eval <<-"end_eval", __FILE__, __LINE__
-
-          verify :method => :post, :only => [ :destroy#{suffix}, :create#{suffix}, :update#{suffix} ],
-                 :redirect_to => { :action => :list#{suffix} }
-
-
-          def list#{suffix}
-            @#{singular_name}_pages, @#{plural_name} = paginate :#{plural_name}, :per_page => 10
-            render#{suffix}_scaffold "list#{suffix}"
-          end
-
-          def show#{suffix}
-            @#{singular_name} = #{class_name}.find(params[:id])
-            render#{suffix}_scaffold
-          end
-
-          def destroy#{suffix}
-            #{class_name}.find(params[:id]).destroy
-            redirect_to :action => "list#{suffix}"
-          end
-
-          def new#{suffix}
-            @#{singular_name} = #{class_name}.new
-            render#{suffix}_scaffold
-          end
-
-          def create#{suffix}
-            @#{singular_name} = #{class_name}.new(params[:#{singular_name}])
-            if @#{singular_name}.save
-              flash[:notice] = "#{class_name} was successfully created"
-              redirect_to :action => "list#{suffix}"
-            else
-              render#{suffix}_scaffold('new')
-            end
-          end
-
-          def edit#{suffix}
-            @#{singular_name} = #{class_name}.find(params[:id])
-            render#{suffix}_scaffold
-          end
-
-          def update#{suffix}
-            @#{singular_name} = #{class_name}.find(params[:id])
-            @#{singular_name}.attributes = params[:#{singular_name}]
-
-            if @#{singular_name}.save
-              flash[:notice] = "#{class_name} was successfully updated"
-              redirect_to :action => "show#{suffix}", :id => @#{singular_name}
-            else
-              render#{suffix}_scaffold('edit')
-            end
-          end
-
-          private
-            def render#{suffix}_scaffold(action=nil)
-              action ||= caller_method_name(caller)
-              # logger.info ("testing template:" + "\#{self.class.controller_path}/\#{action}") if logger
-
-              if template_exists?("\#{self.class.controller_path}/\#{action}")
-                render :action => action
-              else
-                @scaffold_class = #{class_name}
-                @scaffold_singular_name, @scaffold_plural_name = "#{singular_name}", "#{plural_name}"
-                @scaffold_suffix = "#{suffix}"
-                add_instance_variables_to_assigns
-
-                @template.instance_variable_set("@content_for_layout", @template.render_file(scaffold_path(action.sub(/#{suffix}$/, "")), false))
-
-                if !active_layout.nil?
-                  render :file => active_layout, :use_full_path => true
-                else
-                  render :file => scaffold_path('layout')
-                end
-              end
-            end
-
-            def scaffold_path(template_name)
-              File.dirname(__FILE__) + "/templates/scaffolds/" + template_name + ".rhtml"
-            end
-
-            def caller_method_name(caller)
-              caller.first.scan(/`(.*)'/).first.first # ' ruby-mode
-            end
-        end_eval
-      end
-    end
-  end
-end

data/rails/vendor/rails/actionpack/lib/action_controller/session/active_record_store.rb

@@ -1,335 +0,0 @@
-require 'cgi'
-require 'cgi/session'
-require 'digest/md5'
-require 'base64'
-
-class CGI
-  class Session
-    attr_reader :data
-
-    # Return this session's underlying Session instance. Useful for the DB-backed session stores.
-    def model
-      @dbman.model if @dbman
-    end
-
-
-    # A session store backed by an Active Record class.  A default class is
-    # provided, but any object duck-typing to an Active Record +Session+ class
-    # with text +session_id+ and +data+ attributes is sufficient.
-    #
-    # The default assumes a +sessions+ tables with columns:
-    #   +id+ (numeric primary key),
-    #   +session_id+ (text, or longtext if your session data exceeds 65K), and
-    #   +data+ (text or longtext; careful if your session data exceeds 65KB).
-    # The +session_id+ column should always be indexed for speedy lookups.
-    # Session data is marshaled to the +data+ column in Base64 format.
-    # If the data you write is larger than the column's size limit,
-    # ActionController::SessionOverflowError will be raised.
-    #
-    # You may configure the table name, primary key, and data column.
-    # For example, at the end of config/environment.rb:
-    #   CGI::Session::ActiveRecordStore::Session.table_name = 'legacy_session_table'
-    #   CGI::Session::ActiveRecordStore::Session.primary_key = 'session_id'
-    #   CGI::Session::ActiveRecordStore::Session.data_column_name = 'legacy_session_data'
-    # Note that setting the primary key to the session_id frees you from
-    # having a separate id column if you don't want it.  However, you must
-    # set session.model.id = session.session_id by hand!  A before_filter
-    # on ApplicationController is a good place.
-    #
-    # Since the default class is a simple Active Record, you get timestamps
-    # for free if you add +created_at+ and +updated_at+ datetime columns to
-    # the +sessions+ table, making periodic session expiration a snap.
-    #
-    # You may provide your own session class implementation, whether a
-    # feature-packed Active Record or a bare-metal high-performance SQL
-    # store, by setting
-    #   +CGI::Session::ActiveRecordStore.session_class = MySessionClass+
-    # You must implement these methods:
-    #   self.find_by_session_id(session_id)
-    #   initialize(hash_of_session_id_and_data)
-    #   attr_reader :session_id
-    #   attr_accessor :data
-    #   save
-    #   destroy
-    #
-    # The example SqlBypass class is a generic SQL session store.  You may
-    # use it as a basis for high-performance database-specific stores.
-    class ActiveRecordStore
-      # The default Active Record class.
-      class Session < ActiveRecord::Base
-        # Customizable data column name.  Defaults to 'data'.
-        cattr_accessor :data_column_name
-        self.data_column_name = 'data'
-
-        before_save :marshal_data!
-        before_save :raise_on_session_data_overflow!
-
-        class << self
-          # Don't try to reload ARStore::Session in dev mode.
-          def reloadable? #:nodoc:
-            false
-          end
-
-          def data_column_size_limit
-            @data_column_size_limit ||= columns_hash[@@data_column_name].limit
-          end
-
-          # Hook to set up sessid compatibility.
-          def find_by_session_id(session_id)
-            setup_sessid_compatibility!
-            find_by_session_id(session_id)
-          end
-
-          def marshal(data)   Base64.encode64(Marshal.dump(data)) if data end
-          def unmarshal(data) Marshal.load(Base64.decode64(data)) if data end
-
-          def create_table!
-            connection.execute <<-end_sql
-              CREATE TABLE #{table_name} (
-                id INTEGER PRIMARY KEY,
-                #{connection.quote_column_name('session_id')} TEXT UNIQUE,
-                #{connection.quote_column_name(@@data_column_name)} TEXT(255)
-              )
-            end_sql
-          end
-
-          def drop_table!
-            connection.execute "DROP TABLE #{table_name}"
-          end
-
-          private
-            # Compatibility with tables using sessid instead of session_id.
-            def setup_sessid_compatibility!
-              # Reset column info since it may be stale.
-              reset_column_information
-              if columns_hash['sessid']
-                def self.find_by_session_id(*args)
-                  find_by_sessid(*args)
-                end
-
-                define_method(:session_id)  { sessid }
-                define_method(:session_id=) { |session_id| self.sessid = session_id }
-              else
-                def self.find_by_session_id(session_id)
-                  find :first, :conditions => ["session_id #{attribute_condition(session_id)}", session_id]
-                end
-              end
-            end
-        end
-
-        # Lazy-unmarshal session state.
-        def data
-          @data ||= self.class.unmarshal(read_attribute(@@data_column_name)) || {}
-        end
-
-        # Has the session been loaded yet?
-        def loaded?
-          !! @data
-        end
-
-        private
-          attr_writer :data
-
-          def marshal_data!
-            return false if !loaded?
-            write_attribute(@@data_column_name, self.class.marshal(self.data))
-          end
-
-          # Ensures that the data about to be stored in the database is not
-          # larger than the data storage column. Raises
-          # ActionController::SessionOverflowError.
-          def raise_on_session_data_overflow!
-            return false if !loaded?
-            limit = self.class.data_column_size_limit
-            if loaded? and limit and read_attribute(@@data_column_name).size > limit
-              raise ActionController::SessionOverflowError
-            end
-          end
-      end
-
-      # A barebones session store which duck-types with the default session
-      # store but bypasses Active Record and issues SQL directly.  This is
-      # an example session model class meant as a basis for your own classes.
-      #
-      # The database connection, table name, and session id and data columns
-      # are configurable class attributes.  Marshaling and unmarshaling
-      # are implemented as class methods that you may override.  By default,
-      # marshaling data is +Base64.encode64(Marshal.dump(data))+ and
-      # unmarshaling data is +Marshal.load(Base64.decode64(data))+.
-      #
-      # This marshaling behavior is intended to store the widest range of
-      # binary session data in a +text+ column.  For higher performance,
-      # store in a +blob+ column instead and forgo the Base64 encoding.
-      class SqlBypass
-        # Use the ActiveRecord::Base.connection by default.
-        cattr_accessor :connection
-
-        # The table name defaults to 'sessions'.
-        cattr_accessor :table_name
-        @@table_name = 'sessions'
-
-        # The session id field defaults to 'session_id'.
-        cattr_accessor :session_id_column
-        @@session_id_column = 'session_id'
-
-        # The data field defaults to 'data'.
-        cattr_accessor :data_column
-        @@data_column = 'data'
-
-        class << self
-
-          def connection
-            @@connection ||= ActiveRecord::Base.connection
-          end
-
-          # Look up a session by id and unmarshal its data if found.
-          def find_by_session_id(session_id)
-            if record = @@connection.select_one("SELECT * FROM #{@@table_name} WHERE #{@@session_id_column}=#{@@connection.quote(session_id)}")
-              new(:session_id => session_id, :marshaled_data => record['data'])
-            end
-          end
-
-          def marshal(data)   Base64.encode64(Marshal.dump(data)) if data end
-          def unmarshal(data) Marshal.load(Base64.decode64(data)) if data end
-
-          def create_table!
-            @@connection.execute <<-end_sql
-              CREATE TABLE #{table_name} (
-                id INTEGER PRIMARY KEY,
-                #{@@connection.quote_column_name(session_id_column)} TEXT UNIQUE,
-                #{@@connection.quote_column_name(data_column)} TEXT
-              )
-            end_sql
-          end
-
-          def drop_table!
-            @@connection.execute "DROP TABLE #{table_name}"
-          end
-        end
-
-        attr_reader :session_id
-        attr_writer :data
-
-        # Look for normal and marshaled data, self.find_by_session_id's way of
-        # telling us to postpone unmarshaling until the data is requested.
-        # We need to handle a normal data attribute in case of a new record.
-        def initialize(attributes)
-          @session_id, @data, @marshaled_data = attributes[:session_id], attributes[:data], attributes[:marshaled_data]
-          @new_record = @marshaled_data.nil?
-        end
-
-        def new_record?
-          @new_record
-        end
-
-        # Lazy-unmarshal session state.
-        def data
-          unless @data
-            if @marshaled_data
-              @data, @marshaled_data = self.class.unmarshal(@marshaled_data) || {}, nil
-            else
-              @data = {}
-            end
-          end
-          @data
-        end
-
-        def loaded?
-          !! @data
-        end
-
-        def save
-          return false if !loaded?
-          marshaled_data = self.class.marshal(data)
-
-          if @new_record
-            @new_record = false
-            @@connection.update <<-end_sql, 'Create session'
-              INSERT INTO #{@@table_name} (
-                #{@@connection.quote_column_name(@@session_id_column)},
-                #{@@connection.quote_column_name(@@data_column)} )
-              VALUES (
-                #{@@connection.quote(session_id)},
-                #{@@connection.quote(marshaled_data)} )
-            end_sql
-          else
-            @@connection.update <<-end_sql, 'Update session'
-              UPDATE #{@@table_name}
-              SET #{@@connection.quote_column_name(@@data_column)}=#{@@connection.quote(marshaled_data)}
-              WHERE #{@@connection.quote_column_name(@@session_id_column)}=#{@@connection.quote(session_id)}
-            end_sql
-          end
-        end
-
-        def destroy
-          unless @new_record
-            @@connection.delete <<-end_sql, 'Destroy session'
-              DELETE FROM #{@@table_name}
-              WHERE #{@@connection.quote_column_name(@@session_id_column)}=#{@@connection.quote(session_id)}
-            end_sql
-          end
-        end
-      end
-
-
-      # The class used for session storage.  Defaults to
-      # CGI::Session::ActiveRecordStore::Session.
-      cattr_accessor :session_class
-      self.session_class = Session
-
-      # Find or instantiate a session given a CGI::Session.
-      def initialize(session, option = nil)
-        session_id = session.session_id
-        unless @session = ActiveRecord::Base.silence { @@session_class.find_by_session_id(session_id) }
-          unless session.new_session
-            raise CGI::Session::NoSession, 'uninitialized session'
-          end
-          @session = @@session_class.new(:session_id => session_id, :data => {})
-          # session saving can be lazy again, because of improved component implementation
-          # therefore next line gets commented out:
-          # @session.save
-        end
-      end
-
-      # Access the underlying session model.
-      def model
-        @session
-      end
-
-      # Restore session state.  The session model handles unmarshaling.
-      def restore
-        if @session
-          @session.data
-        end
-      end
-
-      # Save session store.
-      def update
-        if @session
-          ActiveRecord::Base.silence { @session.save }
-        end
-      end
-
-      # Save and close the session store.
-      def close
-        if @session
-          update
-          @session = nil
-        end
-      end
-
-      # Delete and close the session store.
-      def delete
-        if @session
-          ActiveRecord::Base.silence { @session.destroy }
-          @session = nil
-        end
-      end
-
-      protected
-        def logger
-          ActionController::Base.logger rescue nil
-        end
-    end
-  end
-end