typo 3.99.0

data/vendor/jabber4r/lib/jabber4r/vcard.rb

@@ -0,0 +1,42 @@
+# License: see LICENSE.txt
+#  Jabber4R - Jabber Instant Messaging Library for Ruby
+#  Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+# 
+
+
+module Jabber
+
+  ##
+  # The VCard class holds the parsed VCard data from the Jabber service.
+  #
+  class VCard
+    attr_accessor :given, :family, :middle, :nickname, :email
+    
+    ##
+    # Factory to create the VCard from the ParsedXMLElement
+    #
+    # je:: [ParsedXMLElement] The VCard as an xml element.
+    # return:: [Jabber::VCard] The newly created VCard.
+    #
+    def VCard.from_element(je)
+      card = VCard.new
+      return card unless je
+      card.given = je.N.GIVEN.element_data
+      card.family = je.N.FAMILY.element_data
+      card.middle = je.N.MIDDLE.element_data
+      card.email = je.EMAIL.element_data
+      card.nickname = je.NICKNAME.element_data
+      return card
+    end
+    
+    ##
+    # Dumps the attributes of the VCard
+    # 
+    # return:: [String] The VCard as a string.
    #
+    def to_s
+      "VCARD: [first=#{@given} last=#{@family} nick=#{@nickname} email=#{@email}]"
+    end
+  end
+  
+end
+

data/vendor/plugins/expiring_action_cache/init.rb

@@ -0,0 +1,2 @@
+require 'metafragment'
+require 'actionparamcache'

data/vendor/plugins/expiring_action_cache/lib/actionparamcache.rb

@@ -0,0 +1,113 @@
+module ActionController
+  class AbstractResponse
+
+    # This isn't just +attr_accessor :lifetime+ because we need to trick components into doing
+    # the right thing--it should be possible to do +lifetime = 1.hour+ in a component and have
+    # the lifetime carried back to the original response.  Unfortunately, components are called
+    # with their own copy of the parent's response object.  Fortunately, the copy uses
+    # +dup+, so if we shove the actual lifetime into a hash (or anything even slighty complex),
+    # the +dup+ will leave the parent response and the child response sharing the same
+    # hash, so the lifetime will become a shared resource and The Right Thing will happen.
+    def lifetime
+      @lifetime[:time]
+    end
+    
+    def lifetime=(seconds)
+      # Only allow the lifetime to be lowered--if one component wants 
+      # lifetime=3.hours and another wants lifetime=15.minutes, then
+      # the right thing to do is to always use lifetime=15.minutes, no
+      # matter which order they're called in.
+      return if @lifetime[:time] and @lifetime[:time] < seconds
+      @lifetime[:time] = seconds
+    end
+    
+    def initialize
+      @body, @headers, @session, @assigns = "", DEFAULT_HEADERS.merge("cookie" => []), [], []
+      @lifetime = Hash.new
+    end
+  end
+  
+  module Caching
+    module ActionParams
+      def self.append_features(base) #:nodoc:
+        super
+        base.extend(ClassMethods)
+        base.send(:attr_accessor, :rendered_action_cache)
+      end
+
+      module ClassMethods #:nodoc:
+        def caches_action_with_params(*actions)
+          return unless perform_caching
+          around_filter(ActionParamCacheFilter.new(*actions))
+        end
+      end
+
+      def expire_action_with_params(options = {})
+        return unless perform_caching
+        
+        if options == {}
+          expire_meta_fragment(%r{ACTION_PARAM/.*})
+        else
+          controller = options[:controller] || '[^/]+'
+          action = options[:action] || '[^/]+'
+          keys = (options.reject {|k,v| v.blank?}.keys-[:controller,:action]).sort_by {|k| k.to_s}
+          param_string = keys.collect { |key| "#{key.to_s}=#{controller.params[key]}"}.join('.*')
+          expire_meta_fragment(%r{ACTION_PARAM/[^/]+/#{controller}/#{action}/#{param_string}})
+        end
+      end
+
+      class ActionParamCacheFilter #:nodoc:
+        def initialize(*actions)
+          @actions = actions
+        end
+
+        def cache_key(controller)
+          hostname = controller.request.host_with_port
+          keys = (controller.params.reject {|k,v| v.blank?}.keys-['controller','action']).sort
+          param_string = keys.collect { |key| "#{key.to_s}=#{controller.params[key]}"}.join('&')
+          "ACTION_PARAM/#{hostname}/#{controller.controller_name}/#{controller.action_name}/#{param_string}"
+        end
+
+        def before(controller)
+          return unless @actions.include?(controller.action_name.intern)
+          meta, cache = controller.read_meta_fragment_expire(cache_key(controller))
+          if cache
+            # 304 handling from Tom Fakes,
+            # http://craz8.com/svn/trunk/plugins/action_cache/lib/action_cache.rb
+            request_time = Time.rfc2822(controller.request.env["HTTP_IF_MODIFIED_SINCE"]).utc rescue nil
+            cached_time = meta[:cached_at] rescue nil
+            controller.response.headers['Cache-Control'] = 'max-age=1'
+            controller.response.headers['Last-Modified'] = meta[:cached_at].httpdate rescue nil
+                        
+            if request_time and cached_time <= (request_time + 1)
+              controller.render(:text => "", :status => 304)
+            else
+              controller.render(:text => cache)
+            end
+            
+            controller.rendered_action_cache = true
+            return false
+          else
+            return true
+          end
+        end
+
+        def after(controller)
+          return true if not @actions.include?(controller.action_name.intern) || controller.rendered_action_cache
+          return true if controller.response.headers['Status'] != "200 OK" # without this, we cache errors.  grr
+
+          meta = Hash.new
+          if controller.response.lifetime
+            meta[:expires] = Time.now + controller.response.lifetime
+          end
+          meta[:cached_at] = Time.now.utc
+          controller.response.headers['Cache-Control'] = 'max-age=1'
+          controller.response.headers['Last-Modified'] = meta[:cached_at].httpdate
+          controller.write_meta_fragment(cache_key(controller), meta, controller.response.body)
+        end
+      end
+    end
+  end
+end
+
+ActionController::Caching::ActionParams.append_features(ActionController::Base)

data/vendor/plugins/expiring_action_cache/lib/metafragment.rb

@@ -0,0 +1,46 @@
+module MetaFragmentCache
+  def meta_fragment_key(name)
+    return "META/META/#{name}", "META/DATA/#{name}"
+  end
+  
+  def read_meta_fragment(name, options = nil)
+    metakey, contentkey = meta_fragment_key(name)
+    meta = YAML.load(read_fragment(metakey)) rescue {}
+    content = read_fragment(contentkey)
+    return meta, content
+  end
+  
+  def read_meta_fragment_expire(name, options = nil)
+    meta, content = read_meta_fragment(name, options)
+    if(meta.kind_of? Hash and meta[:expires].kind_of? Time and meta[:expires] < Time.now)
+      expire_meta_fragment(name)
+      return {},nil
+    else
+      return meta, content
+    end
+  end
+  
+  def write_meta_fragment(name, meta, content, options = nil)
+    metakey, contentkey = meta_fragment_key(name)
+    write_fragment(contentkey, content)
+    write_fragment(metakey, YAML.dump(meta))
+  end
+  
+  def expire_meta_fragment(name, options = nil)
+    if(name.kind_of? Regexp)
+      metakey, contentkey = meta_fragment_key('.*'+name.source).collect {|key| Regexp.new("^#{key}")}
+    elsif(name.kind_of? String)
+      metakey, contentkey = meta_fragment_key(name)
+    else
+      raise "MetaFragmentCache only supports regexes and strings as expire keys"
+    end
+    expire_fragment(metakey)
+    expire_fragment(contentkey)
+  end
+end
+
+module ActionController
+  class Base
+    include MetaFragmentCache
+  end
+end

data/vendor/plugins/upload_progress/CHANGELOG

@@ -0,0 +1,3 @@
+*SVN*
+
+* Make Upload Progress work with edge Rails [3526] and higher, retain compatibility to earlier builds

data/vendor/plugins/upload_progress/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2004 Sean Treadway, Thomas Fuchs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/plugins/upload_progress/README

@@ -0,0 +1,45 @@
+=Overview
+
+The upload progress plugin will alter your rails CGI handling to track the uploaded status of multipart/form encoded posts.  The plugin will also add helper methods to create an AJAX updating progress bar.
+
+==Installing
+
+Run "script/plugin upload_progress" or checkout the source into your plugins folder.
+
+	svn checkout http://dev.rubyonrails.com/svn/plugins/upload_progress
+
+Expand this archive in your RAILS_ROOT/vendor/plugins directory.  The resulting plugin directory should look like:
+
+	RAILS_ROOT/vendor/plugins/upload_progress/
+	RAILS_ROOT/vendor/plugins/upload_progress/README.txt
+	RAILS_ROOT/vendor/plugins/upload_progress/Rakefile
+	RAILS_ROOT/vendor/plugins/upload_progress/init.rb
+	RAILS_ROOT/vendor/plugins/upload_progress/public/
+	RAILS_ROOT/vendor/plugins/upload_progress/public/stylesheets/
+	RAILS_ROOT/vendor/plugins/upload_progress/public/stylesheets/upload_progress.css
+	RAILS_ROOT/vendor/plugins/upload_progress/lib/
+	RAILS_ROOT/vendor/plugins/upload_progress/doc/
+	RAILS_ROOT/vendor/plugins/upload_progress/test/
+
+The stylesheets included in public/stylesheets are used as a guideline for styling your progress bar and status messages.  You can copy them directly into your own public/stylesheets folder or copy and paste.
+
+==Documentation
+
+You can create the documentation by running:
+
+	rake rdoc
+
+==Requirements
+
+The requirments for getting periodic upload progress updates can be found here:
+
+http://sean.treadway.info/articles/2005/07/18/upload-progress-checklist
+
+==Credits
+
+Sean Treadway <seant@superchannel.org> http://sean.treadway.info
+Thomas Fuchs <thomas@fesch.at> http://mir.aculo.us
+
+==License
+
+This plugin is released under the MIT license.  See MIT-LICENSE for details

data/vendor/plugins/upload_progress/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the upload progress plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the upload progress plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Upload progress'
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('README.txt')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/vendor/plugins/upload_progress/init.rb

@@ -0,0 +1,7 @@
+require 'multipart_progress'
+require 'progress'
+require 'upload_progress'
+require 'upload_progress_helper'
+
+ActionController::Base.send(:include, UploadProgress)
+ActionView::Base.send(:include, UploadProgress::UploadProgressHelper)

data/vendor/plugins/upload_progress/lib/multipart_progress.rb

@@ -0,0 +1,169 @@
+# == Overview
+#
+# This module will extend the CGI module with methods to track the upload
+# progress for multipart forms for use with progress meters.  The progress is
+# saved in the session to be used from any request from any server with the
+# same session.  In other words, this module will work across application
+# instances.
+#
+# === Usage
+#
+# Just do your file-uploads as you normally would, but include an upload_id in
+# the query string of your form action.  Your form post action should look
+# like:
+#
+#   <form method="post" enctype="multipart/form-data" action="postaction?upload_id=SOMEIDYOUSET">
+#     <input type="file" name="client_file"/>
+#   </form>
+#
+# Query the upload state in a progress by reading the progress from the session
+#
+#   class UploadController < ApplicationController
+#     def upload_status
+#       render :text => "Percent complete: " + @session[:uploads]['SOMEIDYOUSET'].completed_percent"
+#     end
+#   end
+#
+# === Session options
+#
+# Upload progress uses the session options defined in 
+# ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS.  If you are passing
+# custom session options to your dispatcher then please follow the
+# "recommended way to change session options":http://wiki.rubyonrails.com/rails/show/HowtoChangeSessionOptions
+#
+# === Update frequency
+#
+# During an upload, the progress will be written to the session every 2
+# seconds.  This prevents excessive writes yet maintains a decent picture of
+# the upload progress for larger files.  
+#
+# User interfaces that update more often that every 2 seconds will display the same results.
+# Consider this update frequency when designing your progress polling.
+#
+
+require 'cgi'
+
+class CGI #:nodoc:
+  class ProgressIO < SimpleDelegator #:nodoc:
+    MIN_SAVE_INTERVAL = 1.0         # Number of seconds between session saves
+
+    attr_reader :progress, :session
+
+    def initialize(orig_io, progress, session)
+      @session = session
+      @progress = progress
+      
+      @start_time = Time.now
+      @last_save_time = @start_time
+      save_progress
+      
+      super(orig_io)
+    end
+
+    def read(*args)
+      data = __getobj__.read(*args)
+
+      if data and data.size > 0
+        now = Time.now
+        elapsed =  now - @start_time
+        progress.update!(data.size, elapsed)
+
+        if now - @last_save_time > MIN_SAVE_INTERVAL
+          save_progress 
+          @last_save_time = now 
+        end
+      else
+        ActionController::Base.logger.debug("CGI::ProgressIO#read returns nothing when it should return nil if IO is finished: [#{args.inspect}], a cancelled upload or old FCGI bindings.  Resetting the upload progress")
+
+        progress.reset!
+        save_progress
+      end
+
+      data
+    end
+
+    def save_progress
+      @session.update 
+    end
+
+    def finish
+      @session.update
+      ActionController::Base.logger.debug("Finished processing multipart upload in #{@progress.elapsed_seconds.to_s}s")
+    end
+  end
+
+  module QueryExtension #:nodoc:
+    # Need to do lazy aliasing on the instance that we are extending because of the way QueryExtension
+    # gets included for each instance of the CGI object rather than on a module level.  This method is a 
+    # bit obtrusive because we are overriding CGI::QueryExtension::extended which could be used in the 
+    # future.  Need to research a better method
+    def self.extended(obj)
+      obj.instance_eval do
+        # unless defined? will prevent clobbering the progress IO on multiple extensions
+        alias :stdinput_without_progress :stdinput unless defined? stdinput_without_progress
+        alias :stdinput :stdinput_with_progress 
+      end
+    end
+
+    def stdinput_with_progress
+      @stdin_with_progress or stdinput_without_progress
+    end
+
+    private
+    # Bootstrapped on UploadProgress::upload_status_for
+    def read_multipart_with_progress(boundary, content_length)
+      begin
+        begin
+          # Session disabled if the default session options have been set to 'false'
+          options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS
+          raise RuntimeError.new("Multipart upload progress disabled, no session options") unless options
+
+          options = options.stringify_keys
+       
+          # Pull in the application controller to satisfy any dependencies on class definitions
+          # of instances stored in the session.
+          # Be sure to stay compatible with Rails 1.0/const_load!
+          if Object.const_defined?(:Controllers) and Controllers.respond_to?(:const_load!)
+            Controllers.const_load!(:ApplicationController, "application") unless Controllers.const_defined?(:ApplicationController)
+          else
+            require_dependency('application.rb') unless Object.const_defined?(:ApplicationController)
+          end
+
+          # Assumes that @cookies has already been setup
+          # Raises nomethod if upload_id is not defined
+          @params = CGI::parse(read_params_from_query)
+          upload_id = @params[(options['upload_key'] || 'upload_id')].first
+          raise RuntimeError.new("Multipart upload progress disabled, no upload id in query string") unless upload_id
+
+          upload_progress = UploadProgress::Progress.new(content_length)
+
+          session = Session.new(self, options)
+          session[:uploads] = {} unless session[:uploads]
+          session[:uploads].delete(upload_id) # in case the same upload id is used twice
+          session[:uploads][upload_id] = upload_progress
+
+          @stdin_with_progress = CGI::ProgressIO.new(stdinput_without_progress, upload_progress, session)
+          ActionController::Base.logger.debug("Multipart upload with progress (id: #{upload_id}, size: #{content_length})")
+        rescue
+          ActionController::Base.logger.debug("Exception during setup of read_multipart_with_progress: #{$!}")
+        end
+      ensure
+        begin
+          params = read_multipart_without_progress(boundary, content_length)
+          @stdin_with_progress.finish if @stdin_with_progress.respond_to? :finish
+        ensure
+          @stdin_with_progress = nil
+          session.close if session
+        end
+      end
+      params 
+    end
+
+    # Prevent redefinition of aliases on multiple includes
+    unless private_instance_methods.include?("read_multipart_without_progress")
+      alias_method :read_multipart_without_progress, :read_multipart 
+      alias_method :read_multipart, :read_multipart_with_progress
+    end
+
+  end
+end