imagine_cms 3.0.0.beta6 → 3.0.0.beta7

data/lib/prototype_legacy_helper/test/test_prototype_helper.rb

@@ -0,0 +1,297 @@
+if ENV['RAILS_ROOT']
+  environment = File.expand_path('vendor/gems/environment', ENV['RAILS_ROOT'])
+  require environment if File.exist?("#{environment}.rb")
+end
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'test/unit'
+require 'action_view'
+require 'action_controller'
+require 'active_model'
+require 'prototype_helper'
+
+class Bunny < Struct.new(:Bunny, :id)
+end
+
+class Author
+  extend ActiveModel::Naming
+
+  attr_reader :id
+  def save; @id = 1 end
+  def new_record?; @id.nil? end
+  def name
+    @id.nil? ? 'new author' : "author ##{@id}"
+  end
+end
+
+class Article
+  extend ActiveModel::Naming
+
+  attr_reader :id
+  attr_reader :author_id
+  def save; @id = 1; @author_id = 1 end
+  def new_record?; @id.nil? end
+  def name
+    @id.nil? ? 'new article' : "article ##{@id}"
+  end
+end
+
+class Author::Nested < Author; end
+
+class PrototypeHelperTest < ActionView::TestCase
+  attr_accessor :formats, :output_buffer, :template_format
+
+  def _evaluate_assigns_and_ivars() end
+
+  def reset_formats(format)
+    @format = format
+  end
+
+  def setup
+    @record = @author = Author.new
+    @article = Article.new
+    super
+    @template = self
+    @controller = Class.new do
+      def url_for(options)
+        if options.is_a?(String)
+          options
+        else
+          url =  "http://www.example.com/"
+          url << options[:action].to_s if options and options[:action]
+          url << "?a=#{options[:a]}" if options && options[:a]
+          url << "&b=#{options[:b]}" if options && options[:a] && options[:b]
+          url
+        end
+      end
+    end.new
+  end
+
+
+  def test_observe_form
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Observer('cart', 2, function(element, value) {new Ajax.Request('http://www.example.com/cart_changed', {asynchronous:true, evalScripts:true, parameters:value})})\n//]]>\n</script>),
+      observe_form("cart", :frequency => 2, :url => { :action => "cart_changed" })
+  end
+
+  def test_observe_form_using_function_for_callback
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Observer('cart', 2, function(element, value) {alert('Form changed')})\n//]]>\n</script>),
+      observe_form("cart", :frequency => 2, :function => "alert('Form changed')")
+  end
+
+  def test_observe_field
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.Observer('glass', 300, function(element, value) {new Ajax.Request('http://www.example.com/reorder_if_empty', {asynchronous:true, evalScripts:true, parameters:value})})\n//]]>\n</script>),
+      observe_field("glass", :frequency => 5.minutes, :url => { :action => "reorder_if_empty" })
+  end
+
+  def test_observe_field_using_with_option
+    expected = %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.Observer('glass', 300, function(element, value) {new Ajax.Request('http://www.example.com/check_value', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(value)})})\n//]]>\n</script>)
+    assert_dom_equal expected, observe_field("glass", :frequency => 5.minutes, :url => { :action => "check_value" }, :with => 'id')
+    assert_dom_equal expected, observe_field("glass", :frequency => 5.minutes, :url => { :action => "check_value" }, :with => "'id=' + encodeURIComponent(value)")
+  end
+
+  def test_observe_field_using_json_in_with_option
+    expected = %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.Observer('glass', 300, function(element, value) {new Ajax.Request('http://www.example.com/check_value', {asynchronous:true, evalScripts:true, parameters:{'id':value}})})\n//]]>\n</script>)
+    assert_dom_equal expected, observe_field("glass", :frequency => 5.minutes, :url => { :action => "check_value" }, :with => "{'id':value}")
+  end
+
+  def test_observe_field_using_function_for_callback
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.Observer('glass', 300, function(element, value) {alert('Element changed')})\n//]]>\n</script>),
+      observe_field("glass", :frequency => 5.minutes, :function => "alert('Element changed')")
+  end
+
+  def test_observe_field_without_frequency
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.EventObserver('glass', function(element, value) {new Ajax.Request('http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:value})})\n//]]>\n</script>),
+      observe_field("glass")
+  end
+
+
+  def test_periodically_call_remote
+    assert_dom_equal %(<script type="text/javascript">\n//<![CDATA[\nnew PeriodicalExecuter(function() {new Ajax.Updater('schremser_bier', 'http://www.example.com/mehr_bier', {asynchronous:true, evalScripts:true})}, 10)\n//]]>\n</script>),
+      periodically_call_remote(:update => "schremser_bier", :url => { :action => "mehr_bier" })
+  end
+
+  def test_periodically_call_remote_with_frequency
+    assert_dom_equal(
+      "<script type=\"text/javascript\">\n//<![CDATA[\nnew PeriodicalExecuter(function() {new Ajax.Request('http://www.example.com/', {asynchronous:true, evalScripts:true})}, 2)\n//]]>\n</script>",
+      periodically_call_remote(:frequency => 2)
+    )
+  end
+
+
+  def test_form_remote_tag
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  })
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => { :success => "glass_of_beer" }, :url => { :action => :fast  })
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({failure:'glass_of_water'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => { :failure => "glass_of_water" }, :url => { :action => :fast  })
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer',failure:'glass_of_water'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => { :success => 'glass_of_beer', :failure => "glass_of_water" }, :url => { :action => :fast  })
+  end
+
+  def test_form_remote_tag_with_method
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\"><div style='margin:0;padding:0;display:inline'><input name='_method' type='hidden' value='put' /></div>),
+      form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, :html => { :method => :put })
+  end
+
+  def test_form_remote_tag_with_block_in_erb
+    __in_erb_template = ''
+    form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }) { concat "Hello world!" }
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">Hello world!</form>), output_buffer
+  end
+
+  def test_on_callbacks
+    callbacks = [:uninitialized, :loading, :loaded, :interactive, :complete, :success, :failure]
+    callbacks.each do |callback|
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, callback=>"monkeys();")
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => { :success => "glass_of_beer" }, :url => { :action => :fast  }, callback=>"monkeys();")
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({failure:'glass_of_beer'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => { :failure => "glass_of_beer" }, :url => { :action => :fast  }, callback=>"monkeys();")
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer',failure:'glass_of_water'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => { :success => "glass_of_beer", :failure => "glass_of_water" }, :url => { :action => :fast  }, callback=>"monkeys();")
+    end
+
+    #HTTP status codes 200 up to 599 have callbacks
+    #these should work
+    100.upto(599) do |callback|
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, callback=>"monkeys();")
+    end
+
+    #test 200 and 404
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on200:function(request){monkeys();}, on404:function(request){bananas();}, parameters:Form.serialize(this)}); return false;">),
+      form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, 200=>"monkeys();", 404=>"bananas();")
+
+    #these shouldn't
+    1.upto(99) do |callback|
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, callback=>"monkeys();")
+    end
+    600.upto(999) do |callback|
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, callback=>"monkeys();")
+    end
+
+    #test ultimate combo
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on200:function(request){monkeys();}, on404:function(request){bananas();}, onComplete:function(request){c();}, onFailure:function(request){f();}, onLoading:function(request){c1()}, onSuccess:function(request){s()}, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, :loading => "c1()", :success => "s()", :failure => "f();", :complete => "c();", 200=>"monkeys();", 404=>"bananas();")
+  end
+
+  def test_remote_form_for_with_record_identification_with_new_record
+    remote_form_for(@record, {:html => { :id => 'create-author' }}) {}
+
+    expected = %(<form action='#{authors_path}' onsubmit="new Ajax.Request('#{authors_path}', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;" class='new_author' id='create-author' method='post'></form>)
+    assert_dom_equal expected, output_buffer
+  end
+
+  def test_remote_form_for_with_record_identification_without_html_options
+    remote_form_for(@record) {}
+
+    expected = %(<form action='#{authors_path}' onsubmit="new Ajax.Request('#{authors_path}', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;" class='new_author' method='post' id='new_author'></form>)
+    assert_dom_equal expected, output_buffer
+  end
+
+  def test_remote_form_for_with_record_identification_with_existing_record
+    @record.save
+    remote_form_for(@record) {}
+
+    expected = %(<form action='#{author_path(@record)}' id='edit_author_1' method='post' onsubmit="new Ajax.Request('#{author_path(@record)}', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;" class='edit_author'><div style='margin:0;padding:0;display:inline'><input name='_method' type='hidden' value='put' /></div></form>)
+    assert_dom_equal expected, output_buffer
+  end
+
+  def test_remote_form_for_with_new_object_in_list
+    remote_form_for([@author, @article]) {}
+
+    expected = %(<form action='#{author_articles_path(@author)}' onsubmit="new Ajax.Request('#{author_articles_path(@author)}', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;" class='new_article' method='post' id='new_article'></form>)
+    assert_dom_equal expected, output_buffer
+  end
+
+  def test_remote_form_for_with_existing_object_in_list
+    @author.save
+    @article.save
+    remote_form_for([@author, @article]) {}
+
+    expected = %(<form action='#{author_article_path(@author, @article)}' id='edit_article_1' method='post' onsubmit="new Ajax.Request('#{author_article_path(@author, @article)}', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;" class='edit_article'><div style='margin:0;padding:0;display:inline'><input name='_method' type='hidden' value='put' /></div></form>)
+    assert_dom_equal expected, output_buffer
+  end
+
+
+  def test_button_to_remote
+    assert_dom_equal %(<input class=\"fine\" type=\"button\" value=\"Remote outpost\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true});\" />),
+      button_to_remote("Remote outpost", { :url => { :action => "whatnot"  }}, { :class => "fine"  })
+    assert_dom_equal %(<input type=\"button\" value=\"Remote outpost\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onComplete:function(request){alert(request.reponseText)}});\" />),
+      button_to_remote("Remote outpost", :complete => "alert(request.reponseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<input type=\"button\" value=\"Remote outpost\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onSuccess:function(request){alert(request.reponseText)}});\" />),
+      button_to_remote("Remote outpost", :success => "alert(request.reponseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<input type=\"button\" value=\"Remote outpost\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onFailure:function(request){alert(request.reponseText)}});\" />),
+      button_to_remote("Remote outpost", :failure => "alert(request.reponseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<input type=\"button\" value=\"Remote outpost\" onclick=\"new Ajax.Request('http://www.example.com/whatnot?a=10&amp;b=20', {asynchronous:true, evalScripts:true, onFailure:function(request){alert(request.reponseText)}});\" />),
+      button_to_remote("Remote outpost", :failure => "alert(request.reponseText)", :url => { :action => "whatnot", :a => '10', :b => '20' })
+  end
+
+  def test_submit_to_remote
+    assert_dom_equal %(<input name=\"More beer!\" onclick=\"new Ajax.Updater('empty_bottle', 'http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this.form)});\" type=\"button\" value=\"1000000\" />),
+      submit_to_remote("More beer!", 1_000_000, :update => "empty_bottle")
+  end
+
+
+  def test_link_to_remote
+    assert_dom_equal %(<a class=\"fine\" href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", { :url => { :action => "whatnot"  }}, { :class => "fine"  })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onComplete:function(request){alert(request.responseText)}}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :complete => "alert(request.responseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onSuccess:function(request){alert(request.responseText)}}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :success => "alert(request.responseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onFailure:function(request){alert(request.responseText)}}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :failure => "alert(request.responseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot?a=10&amp;b=20', {asynchronous:true, evalScripts:true, onFailure:function(request){alert(request.responseText)}}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :failure => "alert(request.responseText)", :url => { :action => "whatnot", :a => '10', :b => '20' })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:false, evalScripts:true}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :url => { :action => "whatnot" }, :type => :synchronous)
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, insertion:'bottom'}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :url => { :action => "whatnot" }, :position => :bottom)
+  end
+
+  def test_link_to_remote_html_options
+    assert_dom_equal %(<a class=\"fine\" href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", { :url => { :action => "whatnot"  }, :html => { :class => "fine" } })
+  end
+
+  def test_link_to_remote_url_quote_escaping
+    assert_dom_equal %(<a href="#" onclick="new Ajax.Request('http://www.example.com/whatnot\\\'s', {asynchronous:true, evalScripts:true}); return false;">Remote</a>),
+      link_to_remote("Remote", { :url => { :action => "whatnot's" } })
+  end
+
+  protected
+    def request_forgery_protection_token
+      nil
+    end
+
+    def protect_against_forgery?
+      false
+    end
+
+    def create_generator
+      block = Proc.new { |*args| yield *args if block_given? }
+      JavaScriptGenerator.new self, &block
+    end
+
+    def author_path(record)
+      "/authors/#{record.id}"
+    end
+
+    def authors_path
+      "/authors"
+    end
+
+    def author_articles_path(author)
+      "/authors/#{author.id}/articles"
+    end
+
+    def author_article_path(author, article)
+      "/authors/#{author.id}/articles/#{article.id}"
+    end
+end

data/lib/upload_progress/CHANGELOG

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

data/lib/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/lib/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/gems/acts_as_tree → lib/upload_progress}/Rakefile

@@ -5,18 +5,19 @@ require 'rake/rdoctask'
 desc 'Default: run unit tests.'
 task :default => :test
 
-desc 'Test acts_as_tree plugin.'
+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 acts_as_tree plugin.'
+desc 'Generate documentation for the upload progress plugin.'
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'acts_as_tree'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
+  rdoc.title    = 'Upload progress'
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('README.txt')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+

data/lib/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/lib/upload_progress/lib/multipart_progress.rb

@@ -0,0 +1,176 @@
+# == 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
+    
+    # Required because of changes in [4388]
+    unless private_instance_methods.include?("read_params_from_query")
+      def read_params_from_query
+        read_params(:get,nil)
+      end
+    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