webroar 0.2.2 → 0.2.3

data/src/admin_panel/vendor/rails/activerecord/lib/active_record/serializers/xml_serializer.rb

@@ -1,353 +0,0 @@
-module ActiveRecord #:nodoc:
-  module Serialization
-    # Builds an XML document to represent the model. Some configuration is
-    # available through +options+. However more complicated cases should
-    # override ActiveRecord::Base#to_xml.
-    #
-    # By default the generated XML document will include the processing
-    # instruction and all the object's attributes. For example:
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <topic>
-    #     <title>The First Topic</title>
-    #     <author-name>David</author-name>
-    #     <id type="integer">1</id>
-    #     <approved type="boolean">false</approved>
-    #     <replies-count type="integer">0</replies-count>
-    #     <bonus-time type="datetime">2000-01-01T08:28:00+12:00</bonus-time>
-    #     <written-on type="datetime">2003-07-16T09:28:00+1200</written-on>
-    #     <content>Have a nice day</content>
-    #     <author-email-address>david@loudthinking.com</author-email-address>
-    #     <parent-id></parent-id>
-    #     <last-read type="date">2004-04-15</last-read>
-    #   </topic>
-    #
-    # This behavior can be controlled with <tt>:only</tt>, <tt>:except</tt>,
-    # <tt>:skip_instruct</tt>, <tt>:skip_types</tt>, <tt>:dasherize</tt> and <tt>:camelize</tt> .
-    # The <tt>:only</tt> and <tt>:except</tt> options are the same as for the
-    # +attributes+ method. The default is to dasherize all column names, but you
-    # can disable this setting <tt>:dasherize</tt> to +false+. Setting <tt>:camelize</tt>
-    # to +true+ will camelize all column names - this also overrides <tt>:dasherize</tt>.
-    # To not have the column type included in the XML output set <tt>:skip_types</tt> to +true+.
-    #
-    # For instance:
-    #
-    #   topic.to_xml(:skip_instruct => true, :except => [ :id, :bonus_time, :written_on, :replies_count ])
-    #
-    #   <topic>
-    #     <title>The First Topic</title>
-    #     <author-name>David</author-name>
-    #     <approved type="boolean">false</approved>
-    #     <content>Have a nice day</content>
-    #     <author-email-address>david@loudthinking.com</author-email-address>
-    #     <parent-id></parent-id>
-    #     <last-read type="date">2004-04-15</last-read>
-    #   </topic>
-    #
-    # To include first level associations use <tt>:include</tt>:
-    #
-    #   firm.to_xml :include => [ :account, :clients ]
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <firm>
-    #     <id type="integer">1</id>
-    #     <rating type="integer">1</rating>
-    #     <name>37signals</name>
-    #     <clients type="array">
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Summit</name>
-    #       </client>
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Microsoft</name>
-    #       </client>
-    #     </clients>
-    #     <account>
-    #       <id type="integer">1</id>
-    #       <credit-limit type="integer">50</credit-limit>
-    #     </account>
-    #   </firm>
-    #
-    # To include deeper levels of associations pass a hash like this:
-    #
-    #   firm.to_xml :include => {:account => {}, :clients => {:include => :address}}
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <firm>
-    #     <id type="integer">1</id>
-    #     <rating type="integer">1</rating>
-    #     <name>37signals</name>
-    #     <clients type="array">
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Summit</name>
-    #         <address>
-    #           ...
-    #         </address>
-    #       </client>
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Microsoft</name>
-    #         <address>
-    #           ...
-    #         </address>
-    #       </client>
-    #     </clients>
-    #     <account>
-    #       <id type="integer">1</id>
-    #       <credit-limit type="integer">50</credit-limit>
-    #     </account>
-    #   </firm>
-    #
-    # To include any methods on the model being called use <tt>:methods</tt>:
-    #
-    #   firm.to_xml :methods => [ :calculated_earnings, :real_earnings ]
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <calculated-earnings>100000000000000000</calculated-earnings>
-    #     <real-earnings>5</real-earnings>
-    #   </firm>
-    #
-    # To call any additional Procs use <tt>:procs</tt>. The Procs are passed a
-    # modified version of the options hash that was given to +to_xml+:
-    #
-    #   proc = Proc.new { |options| options[:builder].tag!('abc', 'def') }
-    #   firm.to_xml :procs => [ proc ]
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <abc>def</abc>
-    #   </firm>
-    #
-    # Alternatively, you can yield the builder object as part of the +to_xml+ call:
-    #
-    #   firm.to_xml do |xml|
-    #     xml.creator do
-    #       xml.first_name "David"
-    #       xml.last_name "Heinemeier Hansson"
-    #     end
-    #   end
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <creator>
-    #       <first_name>David</first_name>
-    #       <last_name>Heinemeier Hansson</last_name>
-    #     </creator>
-    #   </firm>
-    #
-    # As noted above, you may override +to_xml+ in your ActiveRecord::Base
-    # subclasses to have complete control about what's generated. The general
-    # form of doing this is:
-    #
-    #   class IHaveMyOwnXML < ActiveRecord::Base
-    #     def to_xml(options = {})
-    #       options[:indent] ||= 2
-    #       xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
-    #       xml.instruct! unless options[:skip_instruct]
-    #       xml.level_one do
-    #         xml.tag!(:second_level, 'content')
-    #       end
-    #     end
-    #   end
-    def to_xml(options = {}, &block)
-      serializer = XmlSerializer.new(self, options)
-      block_given? ? serializer.to_s(&block) : serializer.to_s
-    end
-
-    def from_xml(xml)
-      self.attributes = Hash.from_xml(xml).values.first
-      self
-    end
-  end
-
-  class XmlSerializer < ActiveRecord::Serialization::Serializer #:nodoc:
-    def builder
-      @builder ||= begin
-        options[:indent] ||= 2
-        builder = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
-
-        unless options[:skip_instruct]
-          builder.instruct!
-          options[:skip_instruct] = true
-        end
-
-        builder
-      end
-    end
-
-    def root
-      root = (options[:root] || @record.class.to_s.underscore).to_s
-      reformat_name(root)
-    end
-
-    def dasherize?
-      !options.has_key?(:dasherize) || options[:dasherize]
-    end
-
-    def camelize?
-      options.has_key?(:camelize) && options[:camelize]
-    end
-
-    def reformat_name(name)
-      name = name.camelize if camelize?
-      dasherize? ? name.dasherize : name
-    end
-
-    def serializable_attributes
-      serializable_attribute_names.collect { |name| Attribute.new(name, @record) }
-    end
-
-    def serializable_method_attributes
-      Array(options[:methods]).inject([]) do |method_attributes, name|
-        method_attributes << MethodAttribute.new(name.to_s, @record) if @record.respond_to?(name.to_s)
-        method_attributes
-      end
-    end
-
-    def add_attributes
-      (serializable_attributes + serializable_method_attributes).each do |attribute|
-        add_tag(attribute)
-      end
-    end
-
-    def add_procs
-      if procs = options.delete(:procs)
-        [ *procs ].each do |proc|
-          proc.call(options)
-        end
-      end
-    end
-
-    def add_tag(attribute)
-      builder.tag!(
-        reformat_name(attribute.name),
-        attribute.value.to_s,
-        attribute.decorations(!options[:skip_types])
-      )
-    end
-
-    def add_associations(association, records, opts)
-      if records.is_a?(Enumerable)
-        tag = reformat_name(association.to_s)
-        type = options[:skip_types] ? {} : {:type => "array"}
-
-        if records.empty?
-          builder.tag!(tag, type)
-        else
-          builder.tag!(tag, type) do
-            association_name = association.to_s.singularize
-            records.each do |record|
-              if options[:skip_types]
-                record_type = {}
-              else
-                record_class = (record.class.to_s.underscore == association_name) ? nil : record.class.name
-                record_type = {:type => record_class}
-              end
-
-              record.to_xml opts.merge(:root => association_name).merge(record_type)
-            end
-          end
-        end
-      else
-        if record = @record.send(association)
-          record.to_xml(opts.merge(:root => association))
-        end
-      end
-    end
-
-    def serialize
-      args = [root]
-      if options[:namespace]
-        args << {:xmlns=>options[:namespace]}
-      end
-
-      if options[:type]
-        args << {:type=>options[:type]}
-      end
-
-      builder.tag!(*args) do
-        add_attributes
-        procs = options.delete(:procs)
-        add_includes { |association, records, opts| add_associations(association, records, opts) }
-        options[:procs] = procs
-        add_procs
-        yield builder if block_given?
-      end
-    end
-
-    class Attribute #:nodoc:
-      attr_reader :name, :value, :type
-
-      def initialize(name, record)
-        @name, @record = name, record
-
-        @type  = compute_type
-        @value = compute_value
-      end
-
-      # There is a significant speed improvement if the value
-      # does not need to be escaped, as <tt>tag!</tt> escapes all values
-      # to ensure that valid XML is generated. For known binary
-      # values, it is at least an order of magnitude faster to
-      # Base64 encode binary values and directly put them in the
-      # output XML than to pass the original value or the Base64
-      # encoded value to the <tt>tag!</tt> method. It definitely makes
-      # no sense to Base64 encode the value and then give it to
-      # <tt>tag!</tt>, since that just adds additional overhead.
-      def needs_encoding?
-        ![ :binary, :date, :datetime, :boolean, :float, :integer ].include?(type)
-      end
-
-      def decorations(include_types = true)
-        decorations = {}
-
-        if type == :binary
-          decorations[:encoding] = 'base64'
-        end
-
-        if include_types && type != :string
-          decorations[:type] = type
-        end
-
-        if value.nil?
-          decorations[:nil] = true
-        end
-
-        decorations
-      end
-
-      protected
-        def compute_type
-          type = @record.class.serialized_attributes.has_key?(name) ? :yaml : @record.class.columns_hash[name].type
-
-          case type
-            when :text
-              :string
-            when :time
-              :datetime
-            else
-              type
-          end
-        end
-
-        def compute_value
-          value = @record.send(name)
-
-          if formatter = Hash::XML_FORMATTING[type.to_s]
-            value ? formatter.call(value) : nil
-          else
-            value
-          end
-        end
-    end
-
-    class MethodAttribute < Attribute #:nodoc:
-      protected
-        def compute_type
-          Hash::XML_TYPE_NAMES[@record.send(name).class.name] || :string
-        end
-    end
-  end
-end

data/src/admin_panel/vendor/rails/activerecord/lib/active_record/session_store.rb

@@ -1,318 +0,0 @@
-module ActiveRecord
-  # 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 <tt>config/environment.rb</tt>:
-  #   ActiveRecord::SessionStore::Session.table_name = 'legacy_session_table'
-  #   ActiveRecord::SessionStore::Session.primary_key = 'session_id'
-  #   ActiveRecord::SessionStore::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 <tt>session.model.id = session.session_id</tt> 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
-  #   ActiveRecord::SessionStore.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 SessionStore < ActionController::Session::AbstractStore
-    # The default Active Record class.
-    class Session < ActiveRecord::Base
-      ##
-      # :singleton-method:
-      # 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
-        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)
-          ActiveSupport::Base64.encode64(Marshal.dump(data)) if data
-        end
-
-        def unmarshal(data)
-          Marshal.load(ActiveSupport::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=>session_id}
-              end
-            end
-          end
-      end
-
-      # Lazy-unmarshal session state.
-      def data
-        @data ||= self.class.unmarshal(read_attribute(@@data_column_name)) || {}
-      end
-
-      attr_writer :data
-
-      # Has the session been loaded yet?
-      def loaded?
-        !!@data
-      end
-
-      private
-        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
-    #
-    #   ActiveSupport::Base64.encode64(Marshal.dump(data))
-    #
-    # and unmarshaling data is
-    #
-    #   Marshal.load(ActiveSupport::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
-      ##
-      # :singleton-method:
-      # Use the ActiveRecord::Base.connection by default.
-      cattr_accessor :connection
-
-      ##
-      # :singleton-method:
-      # The table name defaults to 'sessions'.
-      cattr_accessor :table_name
-      @@table_name = 'sessions'
-
-      ##
-      # :singleton-method:
-      # The session id field defaults to 'session_id'.
-      cattr_accessor :session_id_column
-      @@session_id_column = 'session_id'
-
-      ##
-      # :singleton-method:
-      # 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)
-          ActiveSupport::Base64.encode64(Marshal.dump(data)) if data
-        end
-
-        def unmarshal(data)
-          Marshal.load(ActiveSupport::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
-    # ActiveRecord::SessionStore::Session
-    cattr_accessor :session_class
-    self.session_class = Session
-
-    SESSION_RECORD_KEY = 'rack.session.record'.freeze
-
-    private
-      def get_session(env, sid)
-        Base.silence do
-          sid ||= generate_sid
-          session = find_session(sid)
-          env[SESSION_RECORD_KEY] = session
-          [sid, session.data]
-        end
-      end
-
-      def set_session(env, sid, session_data)
-        Base.silence do
-          record = env[SESSION_RECORD_KEY] ||= find_session(sid)
-          record.data = session_data
-          return false unless record.save
-
-          session_data = record.data
-          if session_data && session_data.respond_to?(:each_value)
-            session_data.each_value do |obj|
-              obj.clear_association_cache if obj.respond_to?(:clear_association_cache)
-            end
-          end
-        end
-
-        return true
-      end
-
-      def find_session(id)
-        @@session_class.find_by_session_id(id) ||
-          @@session_class.new(:session_id => id, :data => {})
-      end
-  end
-end