Andreas/tracks
1
0
Fork 0
mirror of https://github.com/TracksApp/tracks.git synced 2026-02-07 16:24:21 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Next step in upgrading Tracks to Rails 2.2. Some highlights:

Browse source 
* Ran rake rails:update
* Added old actionwebservice framework
* Updated RSpec and RSpec-Rails
* Removed asset_packager plugin (not compatible, Scott no longer maintaining), and replaced with bundle_fu. See the bundle_fu README for more info.
* Hacks to UJS and ARTS plugins, which are no longer supported. Probably should move off both UJS and RJS.
* Hack to flashobject_helper plugin (upgrade to Rails 2.2-compatible version if/when it comes out.)
* Hack to skinny-spec plugin, for Rails 2.2 compatibility. Should check for official release.
* Hacks to resource_feeder plugin, for Rails 2.2 compatibility. Should check for official release (not likely) or move off it.
* Addressed some deprecation warnings. More to come.
* My mobile mime type hackery is no longer necessary with new Rails features. Yay!
* Updated environment.rb.tmpl with changes

TODO:
* Restore view specs marked pending
* Fix failing integration tests.
* Try selenium tests.
* Investigate OpenID support.
* Address deprecation warnings.
* Consider moving parts of environment.rb to initializers
* Address annoying config.gem warning about highline gem
This commit is contained in:
Luke Melia 2008-11-29 12:00:06 -05:00
parent 6d11ebd1b0
commit 35ae5fc431
394 changed files with 15184 additions and 9936 deletions
Download patch file Download diff file Expand all files Collapse all files

10
vendor/plugins/arts/lib/arts.rb vendored
View file

@ -38,7 +38,7 @@ module Arts
raise "Invalid content type"
end
else
assert_match Regexp.new("new Insertion\.#{position.to_s.camelize}(.*#{item_id}.*,.*?);"),
assert_match /Element\.insert\("#{item_id}", \{.*#{position.to_s.downcase}.*\}.*\)\;/,
@response.body
end
end
@ -130,4 +130,12 @@ module Arts
return create_generator.send(:arguments_for_call, args)
end
end
public
# hack for rails 2.2.2
def with_output_buffer(lines=[], &block)
block.call
end
end

122
vendor/plugins/asset_packager/CHANGELOG vendored
View file

@ -1,122 +0,0 @@
------------------------------------------------------------------------
r52 | sbecker | 2007-11-04 01:38:21 -0400 (Sun, 04 Nov 2007) | 3 lines
* Allow configuration of which environments the helpers should merge scripts with the Synthesis::AssetPackage.merge_environments variable.
* Refactored tests so they can all run together, and not depend on what the RAILS_ENV constant is.
* Only add file extension if it was explicitly passed in, fixes other helpers in rails.
------------------------------------------------------------------------
r51 | sbecker | 2007-10-26 16:24:48 -0400 (Fri, 26 Oct 2007) | 1 line
* Updated jsmin.rb to latest version from 2007-07-20
------------------------------------------------------------------------
r50 | sbecker | 2007-10-23 23:16:07 -0400 (Tue, 23 Oct 2007) | 1 line
Updated CHANGELOG
------------------------------------------------------------------------
r49 | sbecker | 2007-10-23 23:13:27 -0400 (Tue, 23 Oct 2007) | 1 line
* Finally committed the subdirectory patch. (Thanks James Coglan!)
------------------------------------------------------------------------
r48 | sbecker | 2007-10-15 15:10:43 -0400 (Mon, 15 Oct 2007) | 1 line
* Speed up rake tasks and remove rails environment dependencies
------------------------------------------------------------------------
r43 | sbecker | 2007-07-02 15:30:29 -0400 (Mon, 02 Jul 2007) | 1 line
* Updated the docs regarding testing.
------------------------------------------------------------------------
r42 | sbecker | 2007-07-02 15:27:00 -0400 (Mon, 02 Jul 2007) | 1 line
* For production helper test, build packages once - on first setup.
------------------------------------------------------------------------
r41 | sbecker | 2007-07-02 15:14:13 -0400 (Mon, 02 Jul 2007) | 1 line
* Put build_all in test setup and delete_all in test teardown so all tests will pass the on first run of test suite.
------------------------------------------------------------------------
r40 | sbecker | 2007-07-02 14:55:28 -0400 (Mon, 02 Jul 2007) | 1 line
* Fix quotes, add contact info
------------------------------------------------------------------------
r39 | sbecker | 2007-07-02 14:53:52 -0400 (Mon, 02 Jul 2007) | 1 line
* Add note on how to run the tests for asset packager.
------------------------------------------------------------------------
r38 | sbecker | 2007-01-25 15:36:42 -0500 (Thu, 25 Jan 2007) | 1 line
added CHANGELOG w/ subversion log entries
------------------------------------------------------------------------
r37 | sbecker | 2007-01-25 15:34:39 -0500 (Thu, 25 Jan 2007) | 1 line
updated jsmin with new version from 2007-01-23
------------------------------------------------------------------------
r35 | sbecker | 2007-01-15 19:22:16 -0500 (Mon, 15 Jan 2007) | 1 line
require synthesis/asset_package in rake tasks, as Rails 1.2 seems to necessitate
------------------------------------------------------------------------
r34 | sbecker | 2007-01-05 12:22:09 -0500 (Fri, 05 Jan 2007) | 1 line
do a require before including in action view, because when running migrations, the plugin lib files don't automatically get required, causing the include to error out
------------------------------------------------------------------------
r33 | sbecker | 2006-12-23 02:03:41 -0500 (Sat, 23 Dec 2006) | 1 line
updating readme with various tweaks
------------------------------------------------------------------------
r32 | sbecker | 2006-12-23 02:03:12 -0500 (Sat, 23 Dec 2006) | 1 line
updating readme with various tweaks
------------------------------------------------------------------------
r31 | sbecker | 2006-12-23 01:52:25 -0500 (Sat, 23 Dec 2006) | 1 line
updated readme to show how to use different media for stylesheets
------------------------------------------------------------------------
r28 | sbecker | 2006-11-27 21:02:14 -0500 (Mon, 27 Nov 2006) | 1 line
updated compute_public_path, added check for images
------------------------------------------------------------------------
r27 | sbecker | 2006-11-10 18:28:29 -0500 (Fri, 10 Nov 2006) | 1 line
tolerate extra periods in source asset names. fixed subversion revision checking to be file specific, instead of repository specific.
------------------------------------------------------------------------
r26 | sbecker | 2006-06-24 17:04:27 -0400 (Sat, 24 Jun 2006) | 1 line
convert asset_packages_yml var to a class var
------------------------------------------------------------------------
r25 | sbecker | 2006-06-24 12:37:47 -0400 (Sat, 24 Jun 2006) | 1 line
Added ability to include assets by package name. In development, include all uncompressed asset files. In production, include the single compressed asset.
------------------------------------------------------------------------
r24 | sbecker | 2006-06-19 21:57:23 -0400 (Mon, 19 Jun 2006) | 1 line
Updates to README and about.yml
------------------------------------------------------------------------
r23 | sbecker | 2006-06-19 14:55:39 -0400 (Mon, 19 Jun 2006) | 2 lines
Modifying about.yml and README
------------------------------------------------------------------------
r21 | sbecker | 2006-06-19 12:18:32 -0400 (Mon, 19 Jun 2006) | 2 lines
added "formerly known as MergeJS"
------------------------------------------------------------------------
r20 | sbecker | 2006-06-19 12:14:46 -0400 (Mon, 19 Jun 2006) | 2 lines
Updating docs
------------------------------------------------------------------------
r19 | sbecker | 2006-06-19 11:26:08 -0400 (Mon, 19 Jun 2006) | 2 lines
removing compiled test assets from subversion
------------------------------------------------------------------------
r18 | sbecker | 2006-06-19 11:19:59 -0400 (Mon, 19 Jun 2006) | 2 lines
Initial import.
------------------------------------------------------------------------
r17 | sbecker | 2006-06-19 11:18:56 -0400 (Mon, 19 Jun 2006) | 2 lines
Creating directory.
------------------------------------------------------------------------

173
vendor/plugins/asset_packager/README vendored
View file

@ -1,173 +0,0 @@
= AssetPackager
JavaScript and CSS Asset Compression for Production Rails Apps
== Description
When it comes time to deploy your new web application, instead of
sending down a dozen JavaScript and CSS files full of formatting
and comments, this Rails plugin makes it simple to merge and
compress JavaScript and CSS down into one or more files, increasing
speed and saving bandwidth.
When in development, it allows you to use your original versions
and retain formatting and comments for readability and debugging.
Because not all browsers will dependably cache JavaScript and CSS
files with query string parameters, AssetPackager writes a timestamp
or subversion revision stamp (if available) into the merged file names.
Therefore files are correctly cached by the browser AND your users
always get the latest version when you re-deploy.
This code is released under the MIT license (like Ruby). You’re free
to rip it up, enhance it, etc. And if you make any enhancements,
I’d like to know so I can add them back in. Thanks!
* Formerly known as MergeJS.
== Credit
This Rails Plugin was inspired by Cal Henderson's article
"Serving JavaScript Fast" on Vitamin:
http://www.thinkvitamin.com/features/webapps/serving-javascript-fast
It also uses the Ruby JavaScript Minifier created by
Douglas Crockford.
http://www.crockford.com/javascript/jsmin.html
== Key Features
* Merges and compresses JavaScript and CSS when running in production.
* Uses uncompressed originals when running in development.
* Handles caching correctly. (No querystring parameters - filename timestamps)
* Versions each package individually. Updates to files in one won't re-trigger downloading the others.
* Uses subversion revision numbers instead of timestamps if within a subversion controlled directory.
* Guarantees new version will get downloaded the next time you deploy.
== Components
* Rake Task for merging and compressing JavaScript and CSS files.
* Helper functions for including these JavaScript and CSS files in your views.
* YAML configuration file for mapping JavaScript and CSS files to merged versions.
* Rake Task for auto-generating the YAML file from your existing JavaScript files.
== How to Use:
1. Download and install the plugin:
./script/plugin install http://sbecker.net/shared/plugins/asset_packager
2. Run the rake task "asset:packager:create_yml" to generate the /config/asset_packages.yml
file the first time. You will need to reorder files under 'base' so dependencies are loaded
in correct order. Feel free to rename or create new file packages.
IMPORTANT: JavaScript files can break once compressed if each statement doesn't end with a semi-colon.
The minifier puts multiple statements on one line, so if the semi-colon is missing, the statement may no
longer makes sense and cause a syntax error.
Example from a fresh rails app after running the rake task. (Stylesheets is blank because a
default rails app has no stylesheets yet.):
---
javascripts:
- base:
- prototype
- effects
- dragdrop
- controls
- application
stylesheets:
- base: []
Example with multiple merged files:
---
javascripts:
- base:
- prototype
- effects
- controls
- dragdrop
- application
- secondary:
- foo
- bar
stylesheets:
- base:
- screen
- header
- secondary:
- foo
- bar
3. Run the rake task "asset:packager:build_all" to generate the compressed, merged versions
for each package. Whenever you rearrange the yaml file, you'll need to run this task again.
Merging and compressing is expensive, so this is something we want to do once, not every time
your app starts. Thats why its a rake task.
4. Use the helper functions whenever including these files in your application. See below for examples.
5. Potential warning: css compressor function currently removes CSS comments. This might blow
away some CSS hackery. To disable comment removal, comment out /lib/synthesis/asset_package.rb line 176.
== JavaScript Examples
Example call:
<%= javascript_include_merged 'prototype', 'effects', 'controls', 'dragdrop', 'application', 'foo', 'bar' %>
In development, this generates:
<script type="text/javascript" src="/javascripts/prototype.js"></script>
<script type="text/javascript" src="/javascripts/effects.js"></script>
<script type="text/javascript" src="/javascripts/controls.js"></script>
<script type="text/javascript" src="/javascripts/dragdrop.js"></script>
<script type="text/javascript" src="/javascripts/application.js"></script>
<script type="text/javascript" src="/javascripts/foo.js"></script>
<script type="text/javascript" src="/javascripts/bar.js"></script>
In production, this generates:
<script type="text/javascript" src="/javascripts/base_1150571523.js"></script>
<script type="text/javascript" src="/javascripts/secondary_1150729166.js"></script>
Now supports symbols and :defaults as well:
<%= javascript_include_merged :defaults %>
<%= javascript_include_merged :foo, :bar %>
== Stylesheet Examples
Example call:
<%= stylesheet_link_merged 'screen', 'header' %>
In development, this generates:
<link href="/stylesheets/screen.css" media="screen" rel="Stylesheet" type="text/css" />
<link href="/stylesheets/header.css" media="screen" rel="Stylesheet" type="text/css" />
In production this generates:
<link href="/stylesheets/base_1150729166.css" media="screen" rel="Stylesheet" type="text/css" />
== Different CSS Media
All options for stylesheet_link_tag still work, so if you want to specify a different media type:
<%= stylesheet_link_merged :secondary, 'media' => 'print' %>
== Running the tests
So you want to run the tests eh? Ok, then listen:
This plugin has a full suite of tests. But since they
depend on rails, it has to be run in the context of a
rails app, in the vendor/plugins directory. Observe:
> rails newtestapp
> cd newtestapp
> ./script/plugin install http://sbecker.net/shared/plugins/asset_packager
> cd vendor/plugins/asset_packager/
> rake # all tests pass
== License
Copyright (c) 2006 Scott Becker - http://synthesis.sbecker.net
Contact Email: becker.scott@gmail.com
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.

22
vendor/plugins/asset_packager/Rakefile vendored
View file

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

8
vendor/plugins/asset_packager/about.yml vendored
View file

@ -1,8 +0,0 @@
author: Scott Becker
name: AssetPackager
summary: JavaScript and CSS Asset Compression for Production Rails Apps
homepage: http://synthesis.sbecker.net/pages/asset_packager
plugin: http://sbecker.net/shared/plugins/asset_packager
license: MIT
version: 0.2
rails_version: 1.1.2+

2
vendor/plugins/asset_packager/init.rb vendored
View file

@ -1,2 +0,0 @@
require 'synthesis/asset_package_helper'
ActionView::Base.send :include, Synthesis::AssetPackageHelper

1
vendor/plugins/asset_packager/install.rb vendored
View file

@ -1 +0,0 @@
# Install hook code here

205
vendor/plugins/asset_packager/lib/jsmin.rb vendored
View file

@ -1,205 +0,0 @@
#!/usr/bin/ruby
# jsmin.rb 2007-07-20
# Author: Uladzislau Latynski
# This work is a translation from C to Ruby of jsmin.c published by
# Douglas Crockford. Permission is hereby granted to use the Ruby
# version under the same conditions as the jsmin.c on which it is
# based.
#
# /* jsmin.c
# 2003-04-21
#
# Copyright (c) 2002 Douglas Crockford (www.crockford.com)
#
# 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 shall be used for Good, not Evil.
#
# 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.
EOF = -1
$theA = ""
$theB = ""
# isAlphanum -- return true if the character is a letter, digit, underscore,
# dollar sign, or non-ASCII character
def isAlphanum(c)
return false if !c || c == EOF
return ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
(c >= 'A' && c <= 'Z') || c == '_' || c == '$' ||
c == '\\' || c[0] > 126)
end
# get -- return the next character from stdin. Watch out for lookahead. If
# the character is a control character, translate it to a space or linefeed.
def get()
c = $stdin.getc
return EOF if(!c)
c = c.chr
return c if (c >= " " || c == "\n" || c.unpack("c") == EOF)
return "\n" if (c == "\r")
return " "
end
# Get the next character without getting it.
def peek()
lookaheadChar = $stdin.getc
$stdin.ungetc(lookaheadChar)
return lookaheadChar.chr
end
# mynext -- get the next character, excluding comments.
# peek() is used to see if a '/' is followed by a '/' or '*'.
def mynext()
c = get
if (c == "/")
if(peek == "/")
while(true)
c = get
if (c <= "\n")
return c
end
end
end
if(peek == "*")
get
while(true)
case get
when "*"
if (peek == "/")
get
return " "
end
when EOF
raise "Unterminated comment"
end
end
end
end
return c
end
# action -- do something! What you do is determined by the argument: 1
# Output A. Copy B to A. Get the next B. 2 Copy B to A. Get the next B.
# (Delete A). 3 Get the next B. (Delete B). action treats a string as a
# single character. Wow! action recognizes a regular expression if it is
# preceded by ( or , or =.
def action(a)
if(a==1)
$stdout.write $theA
end
if(a==1 || a==2)
$theA = $theB
if ($theA == "\'" || $theA == "\"")
while (true)
$stdout.write $theA
$theA = get
break if ($theA == $theB)
raise "Unterminated string literal" if ($theA <= "\n")
if ($theA == "\\")
$stdout.write $theA
$theA = get
end
end
end
end
if(a==1 || a==2 || a==3)
$theB = mynext
if ($theB == "/" && ($theA == "(" || $theA == "," || $theA == "=" ||
$theA == ":" || $theA == "[" || $theA == "!" ||
$theA == "&" || $theA == "|" || $theA == "?" ||
$theA == "{" || $theA == "}" || $theA == ";" ||
$theA == "\n"))
$stdout.write $theA
$stdout.write $theB
while (true)
$theA = get
if ($theA == "/")
break
elsif ($theA == "\\")
$stdout.write $theA
$theA = get
elsif ($theA <= "\n")
raise "Unterminated RegExp Literal"
end
$stdout.write $theA
end
$theB = mynext
end
end
end
# jsmin -- Copy the input to the output, deleting the characters which are
# insignificant to JavaScript. Comments will be removed. Tabs will be
# replaced with spaces. Carriage returns will be replaced with linefeeds.
# Most spaces and linefeeds will be removed.
def jsmin
$theA = "\n"
action(3)
while ($theA != EOF)
case $theA
when " "
if (isAlphanum($theB))
action(1)
else
action(2)
end
when "\n"
case ($theB)
when "{","[","(","+","-"
action(1)
when " "
action(3)
else
if (isAlphanum($theB))
action(1)
else
action(2)
end
end
else
case ($theB)
when " "
if (isAlphanum($theA))
action(1)
else
action(3)
end
when "\n"
case ($theA)
when "}","]",")","+","-","\"","\\", "'", '"'
action(1)
else
if (isAlphanum($theA))
action(1)
else
action(3)
end
end
else
action(1)
end
end
end
end
ARGV.each do |anArg|
$stdout.write "// #{anArg}\n"
end
jsmin

233
vendor/plugins/asset_packager/lib/synthesis/asset_package.rb vendored
View file

@ -1,233 +0,0 @@
require 'yaml'
module Synthesis
class AssetPackage
# class variables
@@asset_packages_yml = $asset_packages_yml ||
(File.exists?("#{RAILS_ROOT}/config/asset_packages.yml") ? YAML.load_file("#{RAILS_ROOT}/config/asset_packages.yml") : nil)
# singleton methods
class << self
def merge_environments=(environments)
@@merge_environments = environments
end
def merge_environments
@@merge_environments ||= ["production"]
end
def parse_path(path)
/^(?:(.*)\/)?([^\/]+)$/.match(path).to_a
end
def find_by_type(asset_type)
@@asset_packages_yml[asset_type].map { |p| self.new(asset_type, p) }
end
def find_by_target(asset_type, target)
package_hash = @@asset_packages_yml[asset_type].find {|p| p.keys.first == target }
package_hash ? self.new(asset_type, package_hash) : nil
end
def find_by_source(asset_type, source)
path_parts = parse_path(source)
package_hash = @@asset_packages_yml[asset_type].find do |p|
key = p.keys.first
p[key].include?(path_parts[2]) && (parse_path(key)[1] == path_parts[1])
end
package_hash ? self.new(asset_type, package_hash) : nil
end
def targets_from_sources(asset_type, sources)
package_names = Array.new
sources.each do |source|
package = find_by_target(asset_type, source) || find_by_source(asset_type, source)
package_names << (package ? package.current_file : source)
end
package_names.uniq
end
def sources_from_targets(asset_type, targets)
source_names = Array.new
targets.each do |target|
package = find_by_target(asset_type, target)
source_names += (package ? package.sources.collect do |src|
package.target_dir.gsub(/^(.+)$/, '\1/') + src
end : target.to_a)
end
source_names.uniq
end
def build_all
@@asset_packages_yml.keys.each do |asset_type|
@@asset_packages_yml[asset_type].each { |p| self.new(asset_type, p).build }
end
end
def delete_all
@@asset_packages_yml.keys.each do |asset_type|
@@asset_packages_yml[asset_type].each { |p| self.new(asset_type, p).delete_all_builds }
end
end
def create_yml
unless File.exists?("#{RAILS_ROOT}/config/asset_packages.yml")
asset_yml = Hash.new
asset_yml['javascripts'] = [{"base" => build_file_list("#{RAILS_ROOT}/public/javascripts", "js")}]
asset_yml['stylesheets'] = [{"base" => build_file_list("#{RAILS_ROOT}/public/stylesheets", "css")}]
File.open("#{RAILS_ROOT}/config/asset_packages.yml", "w") do |out|
YAML.dump(asset_yml, out)
end
log "config/asset_packages.yml example file created!"
log "Please reorder files under 'base' so dependencies are loaded in correct order."
else
log "config/asset_packages.yml already exists. Aborting task..."
end
end
end
# instance methods
attr_accessor :asset_type, :target, :target_dir, :sources
def initialize(asset_type, package_hash)
target_parts = self.class.parse_path(package_hash.keys.first)
@target_dir = target_parts[1].to_s
@target = target_parts[2].to_s
@sources = package_hash[package_hash.keys.first]
@asset_type = asset_type
@asset_path = ($asset_base_path ? "#{$asset_base_path}/" : "#{RAILS_ROOT}/public/") +
"#{@asset_type}#{@target_dir.gsub(/^(.+)$/, '/\1')}"
@extension = get_extension
@match_regex = Regexp.new("\\A#{@target}_\\d+.#{@extension}\\z")
end
def current_file
@target_dir.gsub(/^(.+)$/, '\1/') +
Dir.new(@asset_path).entries.delete_if { |x| ! (x =~ @match_regex) }.sort.reverse[0].chomp(".#{@extension}")
end
def build
delete_old_builds
create_new_build
end
def delete_old_builds
Dir.new(@asset_path).entries.delete_if { |x| ! (x =~ @match_regex) }.each do |x|
File.delete("#{@asset_path}/#{x}") unless x.index(revision.to_s)
end
end
def delete_all_builds
Dir.new(@asset_path).entries.delete_if { |x| ! (x =~ @match_regex) }.each do |x|
File.delete("#{@asset_path}/#{x}")
end
end
private
def revision
unless @revision
revisions = [1]
@sources.each do |source|
revisions << get_file_revision("#{@asset_path}/#{source}.#{@extension}")
end
@revision = revisions.max
end
@revision
end
def get_file_revision(path)
if File.exists?(path)
begin
`svn info #{path}`[/Last Changed Rev: (.*?)\n/][/(\d+)/].to_i
rescue # use filename timestamp if not in subversion
File.mtime(path).to_i
end
else
0
end
end
def create_new_build
if File.exists?("#{@asset_path}/#{@target}_#{revision}.#{@extension}")
log "Latest version already exists: #{@asset_path}/#{@target}_#{revision}.#{@extension}"
else
File.open("#{@asset_path}/#{@target}_#{revision}.#{@extension}", "w") {|f| f.write(compressed_file) }
log "Created #{@asset_path}/#{@target}_#{revision}.#{@extension}"
end
end
def merged_file
merged_file = ""
@sources.each {|s|
File.open("#{@asset_path}/#{s}.#{@extension}", "r") { |f|
merged_file += f.read + "\n"
}
}
merged_file
end
def compressed_file
case @asset_type
when "javascripts" then compress_js(merged_file)
when "stylesheets" then compress_css(merged_file)
end
end
def compress_js(source)
jsmin_path = "#{RAILS_ROOT}/vendor/plugins/asset_packager/lib"
tmp_path = "#{RAILS_ROOT}/tmp/#{@target}_#{revision}"
# write out to a temp file
File.open("#{tmp_path}_uncompressed.js", "w") {|f| f.write(source) }
# compress file with JSMin library
`ruby #{jsmin_path}/jsmin.rb <#{tmp_path}_uncompressed.js >#{tmp_path}_compressed.js \n`
# read it back in and trim it
result = ""
File.open("#{tmp_path}_compressed.js", "r") { |f| result += f.read.strip }
# delete temp files if they exist
File.delete("#{tmp_path}_uncompressed.js") if File.exists?("#{tmp_path}_uncompressed.js")
File.delete("#{tmp_path}_compressed.js") if File.exists?("#{tmp_path}_compressed.js")
result
end
def compress_css(source)
source.gsub!(/\s+/, " ") # collapse space
source.gsub!(/\/\*(.*?)\*\/ /, "") # remove comments - caution, might want to remove this if using css hacks
source.gsub!(/\} /, "}\n") # add line breaks
source.gsub!(/\n$/, "") # remove last break
source.gsub!(/ \{ /, " {") # trim inside brackets
source.gsub!(/; \}/, "}") # trim inside brackets
source
end
def get_extension
case @asset_type
when "javascripts" then "js"
when "stylesheets" then "css"
end
end
def log(message)
puts message
end
def self.build_file_list(path, extension)
re = Regexp.new(".#{extension}\\z")
file_list = Dir.new(path).entries.delete_if { |x| ! (x =~ re) }.map {|x| x.chomp(".#{extension}")}
# reverse javascript entries so prototype comes first on a base rails app
file_list.reverse! if extension == "js"
file_list
end
end
end

67
vendor/plugins/asset_packager/lib/synthesis/asset_package_helper.rb vendored
View file

@ -1,67 +0,0 @@
module Synthesis
module AssetPackageHelper
def should_merge?
AssetPackage.merge_environments.include?(RAILS_ENV)
end
def javascript_include_merged(*sources)
options = sources.last.is_a?(Hash) ? sources.pop.stringify_keys : { }
if sources.include?(:defaults)
sources = sources[0..(sources.index(:defaults))] +
['prototype', 'effects', 'dragdrop', 'controls'] +
(File.exists?("#{RAILS_ROOT}/public/javascripts/application.js") ? ['application'] : []) +
sources[(sources.index(:defaults) + 1)..sources.length]
sources.delete(:defaults)
end
sources.collect!{|s| s.to_s}
sources = (should_merge? ?
AssetPackage.targets_from_sources("javascripts", sources) :
AssetPackage.sources_from_targets("javascripts", sources))
sources.collect {|source| javascript_include_tag(source, options) }.join("\n")
end
def stylesheet_link_merged(*sources)
options = sources.last.is_a?(Hash) ? sources.pop.stringify_keys : { }
sources.collect!{|s| s.to_s}
sources = (should_merge? ?
AssetPackage.targets_from_sources("stylesheets", sources) :
AssetPackage.sources_from_targets("stylesheets", sources))
sources.collect { |source|
source = stylesheet_path(source)
tag("link", { "rel" => "Stylesheet", "type" => "text/css", "media" => "screen", "href" => source }.merge(options))
}.join("\n")
end
private
# rewrite compute_public_path to allow us to not include the query string timestamp
# used by ActionView::Helpers::AssetTagHelper
def compute_public_path(source, dir, ext=nil, add_asset_id=true)
source = source.dup
source << ".#{ext}" if File.extname(source).blank? && ext
unless source =~ %r{^[-a-z]+://}
source = "/#{dir}/#{source}" unless source[0] == ?/
asset_id = rails_asset_id(source)
source << '?' + asset_id if defined?(RAILS_ROOT) and add_asset_id and not asset_id.blank?
source = "#{ActionController::Base.asset_host}#{@controller.request.relative_url_root}#{source}"
end
source
end
# rewrite javascript path function to not include query string timestamp
def javascript_path(source)
compute_public_path(source, 'javascripts', 'js', false)
end
# rewrite stylesheet path function to not include query string timestamp
def stylesheet_path(source)
compute_public_path(source, 'stylesheets', 'css', false)
end
end
end

22
vendor/plugins/asset_packager/tasks/asset_packager_tasks.rake vendored
View file

@ -1,22 +0,0 @@
require File.dirname(__FILE__) + '/../lib/synthesis/asset_package'
namespace :asset do
namespace :packager do
desc "Merge and compress assets"
task :build_all do
Synthesis::AssetPackage.build_all
end
desc "Delete all asset builds"
task :delete_all do
Synthesis::AssetPackage.delete_all
end
desc "Generate asset_packages.yml from existing assets"
task :create_yml do
Synthesis::AssetPackage.create_yml
end
end
end

107
vendor/plugins/asset_packager/test/asset_package_helper_development_test.rb vendored
View file

@ -1,107 +0,0 @@
$:.unshift(File.dirname(__FILE__) + '/../lib')
ENV['RAILS_ENV'] = "development"
require File.dirname(__FILE__) + '/../../../../config/environment'
require 'test/unit'
require 'rubygems'
require 'mocha'
require 'action_controller/test_process'
ActionController::Base.logger = nil
ActionController::Base.ignore_missing_templates = false
ActionController::Routing::Routes.reload rescue nil
$asset_packages_yml = YAML.load_file("#{RAILS_ROOT}/vendor/plugins/asset_packager/test/asset_packages.yml")
$asset_base_path = "#{RAILS_ROOT}/vendor/plugins/asset_packager/test/assets"
class AssetPackageHelperProductionTest < Test::Unit::TestCase
include ActionView::Helpers::TagHelper
include ActionView::Helpers::AssetTagHelper
include Synthesis::AssetPackageHelper
def setup
Synthesis::AssetPackage.any_instance.stubs(:log)
@controller = Class.new do
attr_reader :request
def initialize
@request = Class.new do
def relative_url_root
""
end
end.new
end
end.new
end
def build_js_expected_string(*sources)
sources.map {|s| %(<script src="/javascripts/#{s}.js" type="text/javascript"></script>) }.join("\n")
end
def build_css_expected_string(*sources)
sources.map {|s| %(<link href="/stylesheets/#{s}.css" rel="Stylesheet" type="text/css" media="screen" />) }.join("\n")
end
def test_js_basic
assert_dom_equal build_js_expected_string("prototype"),
javascript_include_merged("prototype")
end
def test_js_multiple_packages
assert_dom_equal build_js_expected_string("prototype", "foo"),
javascript_include_merged("prototype", "foo")
end
def test_js_unpackaged_file
assert_dom_equal build_js_expected_string("prototype", "foo", "not_part_of_a_package"),
javascript_include_merged("prototype", "foo", "not_part_of_a_package")
end
def test_js_multiple_from_same_package
assert_dom_equal build_js_expected_string("prototype", "effects", "controls", "not_part_of_a_package", "foo"),
javascript_include_merged("prototype", "effects", "controls", "not_part_of_a_package", "foo")
end
def test_js_by_package_name
assert_dom_equal build_js_expected_string("prototype", "effects", "controls", "dragdrop"),
javascript_include_merged(:base)
end
def test_js_multiple_package_names
assert_dom_equal build_js_expected_string("prototype", "effects", "controls", "dragdrop", "foo", "bar", "application"),
javascript_include_merged(:base, :secondary)
end
def test_css_basic
assert_dom_equal build_css_expected_string("screen"),
stylesheet_link_merged("screen")
end
def test_css_multiple_packages
assert_dom_equal build_css_expected_string("screen", "foo", "subdir/bar"),
stylesheet_link_merged("screen", "foo", "subdir/bar")
end
def test_css_unpackaged_file
assert_dom_equal build_css_expected_string("screen", "foo", "not_part_of_a_package", "subdir/bar"),
stylesheet_link_merged("screen", "foo", "not_part_of_a_package", "subdir/bar")
end
def test_css_multiple_from_same_package
assert_dom_equal build_css_expected_string("screen", "header", "not_part_of_a_package", "foo", "bar", "subdir/foo", "subdir/bar"),
stylesheet_link_merged("screen", "header", "not_part_of_a_package", "foo", "bar", "subdir/foo", "subdir/bar")
end
def test_css_by_package_name
assert_dom_equal build_css_expected_string("screen", "header"),
stylesheet_link_merged(:base)
end
def test_css_multiple_package_names
assert_dom_equal build_css_expected_string("screen", "header", "foo", "bar", "subdir/foo", "subdir/bar"),
stylesheet_link_merged(:base, :secondary, "subdir/styles")
end
end

153
vendor/plugins/asset_packager/test/asset_package_helper_production_test.rb vendored
View file

@ -1,153 +0,0 @@
$:.unshift(File.dirname(__FILE__) + '/../lib')
require File.dirname(__FILE__) + '/../../../../config/environment'
require 'test/unit'
require 'rubygems'
require 'mocha'
require 'action_controller/test_process'
ActionController::Base.logger = nil
ActionController::Base.ignore_missing_templates = false
ActionController::Routing::Routes.reload rescue nil
$asset_packages_yml = YAML.load_file("#{RAILS_ROOT}/vendor/plugins/asset_packager/test/asset_packages.yml")
$asset_base_path = "#{RAILS_ROOT}/vendor/plugins/asset_packager/test/assets"
class AssetPackageHelperProductionTest < Test::Unit::TestCase
include ActionView::Helpers::TagHelper
include ActionView::Helpers::AssetTagHelper
include Synthesis::AssetPackageHelper
cattr_accessor :packages_built
def setup
Synthesis::AssetPackage.any_instance.stubs(:log)
self.stubs(:should_merge?).returns(true)
@controller = Class.new do
attr_reader :request
def initialize
@request = Class.new do
def relative_url_root
""
end
end.new
end
end.new
build_packages_once
end
def build_packages_once
unless @@packages_built
Synthesis::AssetPackage.build_all
@@packages_built = true
end
end
def build_js_expected_string(*sources)
sources.map {|s| %(<script src="/javascripts/#{s}.js" type="text/javascript"></script>) }.join("\n")
end
def build_css_expected_string(*sources)
sources.map {|s| %(<link href="/stylesheets/#{s}.css" rel="Stylesheet" type="text/css" media="screen" />) }.join("\n")
end
def test_js_basic
current_file = Synthesis::AssetPackage.find_by_source("javascripts", "prototype").current_file
assert_dom_equal build_js_expected_string(current_file),
javascript_include_merged("prototype")
end
def test_js_multiple_packages
current_file1 = Synthesis::AssetPackage.find_by_source("javascripts", "prototype").current_file
current_file2 = Synthesis::AssetPackage.find_by_source("javascripts", "foo").current_file
assert_dom_equal build_js_expected_string(current_file1, current_file2),
javascript_include_merged("prototype", "foo")
end
def test_js_unpackaged_file
current_file1 = Synthesis::AssetPackage.find_by_source("javascripts", "prototype").current_file
current_file2 = Synthesis::AssetPackage.find_by_source("javascripts", "foo").current_file
assert_dom_equal build_js_expected_string(current_file1, current_file2, "not_part_of_a_package"),
javascript_include_merged("prototype", "foo", "not_part_of_a_package")
end
def test_js_multiple_from_same_package
current_file1 = Synthesis::AssetPackage.find_by_source("javascripts", "prototype").current_file
current_file2 = Synthesis::AssetPackage.find_by_source("javascripts", "foo").current_file
assert_dom_equal build_js_expected_string(current_file1, "not_part_of_a_package", current_file2),
javascript_include_merged("prototype", "effects", "controls", "not_part_of_a_package", "foo")
end
def test_js_by_package_name
package_name = Synthesis::AssetPackage.find_by_target("javascripts", "base").current_file
assert_dom_equal build_js_expected_string(package_name),
javascript_include_merged(:base)
end
def test_js_multiple_package_names
package_name1 = Synthesis::AssetPackage.find_by_target("javascripts", "base").current_file
package_name2 = Synthesis::AssetPackage.find_by_target("javascripts", "secondary").current_file
assert_dom_equal build_js_expected_string(package_name1, package_name2),
javascript_include_merged(:base, :secondary)
end
def test_css_basic
current_file = Synthesis::AssetPackage.find_by_source("stylesheets", "screen").current_file
assert_dom_equal build_css_expected_string(current_file),
stylesheet_link_merged("screen")
end
def test_css_multiple_packages
current_file1 = Synthesis::AssetPackage.find_by_source("stylesheets", "screen").current_file
current_file2 = Synthesis::AssetPackage.find_by_source("stylesheets", "foo").current_file
current_file3 = Synthesis::AssetPackage.find_by_source("stylesheets", "subdir/bar").current_file
assert_dom_equal build_css_expected_string(current_file1, current_file2, current_file3),
stylesheet_link_merged("screen", "foo", "subdir/bar")
end
def test_css_unpackaged_file
current_file1 = Synthesis::AssetPackage.find_by_source("stylesheets", "screen").current_file
current_file2 = Synthesis::AssetPackage.find_by_source("stylesheets", "foo").current_file
assert_dom_equal build_css_expected_string(current_file1, current_file2, "not_part_of_a_package"),
stylesheet_link_merged("screen", "foo", "not_part_of_a_package")
end
def test_css_multiple_from_same_package
current_file1 = Synthesis::AssetPackage.find_by_source("stylesheets", "screen").current_file
current_file2 = Synthesis::AssetPackage.find_by_source("stylesheets", "foo").current_file
current_file3 = Synthesis::AssetPackage.find_by_source("stylesheets", "subdir/bar").current_file
assert_dom_equal build_css_expected_string(current_file1, "not_part_of_a_package", current_file2, current_file3),
stylesheet_link_merged("screen", "header", "not_part_of_a_package", "foo", "bar", "subdir/foo", "subdir/bar")
end
def test_css_by_package_name
package_name = Synthesis::AssetPackage.find_by_target("stylesheets", "base").current_file
assert_dom_equal build_css_expected_string(package_name),
stylesheet_link_merged(:base)
end
def test_css_multiple_package_names
package_name1 = Synthesis::AssetPackage.find_by_target("stylesheets", "base").current_file
package_name2 = Synthesis::AssetPackage.find_by_target("stylesheets", "secondary").current_file
package_name3 = Synthesis::AssetPackage.find_by_target("stylesheets", "subdir/styles").current_file
assert_dom_equal build_css_expected_string(package_name1, package_name2, package_name3),
stylesheet_link_merged(:base, :secondary, "subdir/styles")
end
def test_image_tag
timestamp = rails_asset_id("images/rails.png")
assert_dom_equal %(<img alt="Rails" src="/images/rails.png?#{timestamp}" />), image_tag("rails")
end
end

92
vendor/plugins/asset_packager/test/asset_packager_test.rb vendored
View file

@ -1,92 +0,0 @@
require File.dirname(__FILE__) + '/../../../../config/environment'
require 'test/unit'
require 'mocha'
$asset_packages_yml = YAML.load_file("#{RAILS_ROOT}/vendor/plugins/asset_packager/test/asset_packages.yml")
$asset_base_path = "#{RAILS_ROOT}/vendor/plugins/asset_packager/test/assets"
class AssetPackagerTest < Test::Unit::TestCase
include Synthesis
def setup
Synthesis::AssetPackage.any_instance.stubs(:log)
Synthesis::AssetPackage.build_all
end
def teardown
Synthesis::AssetPackage.delete_all
end
def test_find_by_type
js_asset_packages = Synthesis::AssetPackage.find_by_type("javascripts")
assert_equal 2, js_asset_packages.length
assert_equal "base", js_asset_packages[0].target
assert_equal ["prototype", "effects", "controls", "dragdrop"], js_asset_packages[0].sources
end
def test_find_by_target
package = Synthesis::AssetPackage.find_by_target("javascripts", "base")
assert_equal "base", package.target
assert_equal ["prototype", "effects", "controls", "dragdrop"], package.sources
end
def test_find_by_source
package = Synthesis::AssetPackage.find_by_source("javascripts", "controls")
assert_equal "base", package.target
assert_equal ["prototype", "effects", "controls", "dragdrop"], package.sources
end
def test_delete_and_build
Synthesis::AssetPackage.delete_all
js_package_names = Dir.new("#{$asset_base_path}/javascripts").entries.delete_if { |x| ! (x =~ /\A\w+_\d+.js/) }
css_package_names = Dir.new("#{$asset_base_path}/stylesheets").entries.delete_if { |x| ! (x =~ /\A\w+_\d+.css/) }
css_subdir_package_names = Dir.new("#{$asset_base_path}/stylesheets/subdir").entries.delete_if { |x| ! (x =~ /\A\w+_\d+.css/) }
assert_equal 0, js_package_names.length
assert_equal 0, css_package_names.length
assert_equal 0, css_subdir_package_names.length
Synthesis::AssetPackage.build_all
js_package_names = Dir.new("#{$asset_base_path}/javascripts").entries.delete_if { |x| ! (x =~ /\A\w+_\d+.js/) }.sort
css_package_names = Dir.new("#{$asset_base_path}/stylesheets").entries.delete_if { |x| ! (x =~ /\A\w+_\d+.css/) }.sort
css_subdir_package_names = Dir.new("#{$asset_base_path}/stylesheets/subdir").entries.delete_if { |x| ! (x =~ /\A\w+_\d+.css/) }.sort
assert_equal 2, js_package_names.length
assert_equal 2, css_package_names.length
assert_equal 1, css_subdir_package_names.length
assert js_package_names[0].match(/\Abase_\d+.js\z/)
assert js_package_names[1].match(/\Asecondary_\d+.js\z/)
assert css_package_names[0].match(/\Abase_\d+.css\z/)
assert css_package_names[1].match(/\Asecondary_\d+.css\z/)
assert css_subdir_package_names[0].match(/\Astyles_\d+.css\z/)
end
def test_js_names_from_sources
package_names = Synthesis::AssetPackage.targets_from_sources("javascripts", ["prototype", "effects", "noexist1", "controls", "foo", "noexist2"])
assert_equal 4, package_names.length
assert package_names[0].match(/\Abase_\d+\z/)
assert_equal package_names[1], "noexist1"
assert package_names[2].match(/\Asecondary_\d+\z/)
assert_equal package_names[3], "noexist2"
end
def test_css_names_from_sources
package_names = Synthesis::AssetPackage.targets_from_sources("stylesheets", ["header", "screen", "noexist1", "foo", "noexist2"])
assert_equal 4, package_names.length
assert package_names[0].match(/\Abase_\d+\z/)
assert_equal package_names[1], "noexist1"
assert package_names[2].match(/\Asecondary_\d+\z/)
assert_equal package_names[3], "noexist2"
end
def test_should_return_merge_environments_when_set
Synthesis::AssetPackage.merge_environments = ["staging", "production"]
assert_equal ["staging", "production"], Synthesis::AssetPackage.merge_environments
end
def test_should_only_return_production_merge_environment_when_not_set
assert_equal ["production"], Synthesis::AssetPackage.merge_environments
end
end

20
vendor/plugins/asset_packager/test/asset_packages.yml vendored
View file

@ -1,20 +0,0 @@
javascripts:
- base:
- prototype
- effects
- controls
- dragdrop
- secondary:
- foo
- bar
- application
stylesheets:
- base:
- screen
- header
- secondary:
- foo
- bar
- subdir/styles:
- foo
- bar

2
vendor/plugins/asset_packager/test/assets/javascripts/application.js vendored
View file

@ -1,2 +0,0 @@
// Place your application-specific JavaScript functions and classes here
// This file is automatically included by javascript_include_tag :defaults

4
vendor/plugins/asset_packager/test/assets/javascripts/bar.js vendored
View file

@ -1,4 +0,0 @@
bar bar bar
bar bar bar
bar bar bar

815
vendor/plugins/asset_packager/test/assets/javascripts/controls.js vendored
View file

@ -1,815 +0,0 @@
// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// (c) 2005 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
// (c) 2005 Jon Tirsen (http://www.tirsen.com)
// Contributors:
// Richard Livsey
// Rahul Bhargava
// Rob Wills
//
// See scriptaculous.js for full license.
// Autocompleter.Base handles all the autocompletion functionality
// that's independent of the data source for autocompletion. This
// includes drawing the autocompletion menu, observing keyboard
// and mouse events, and similar.
//
// Specific autocompleters need to provide, at the very least,
// a getUpdatedChoices function that will be invoked every time
// the text inside the monitored textbox changes. This method
// should get the text for which to provide autocompletion by
// invoking this.getToken(), NOT by directly accessing
// this.element.value. This is to allow incremental tokenized
// autocompletion. Specific auto-completion logic (AJAX, etc)
// belongs in getUpdatedChoices.
//
// Tokenized incremental autocompletion is enabled automatically
// when an autocompleter is instantiated with the 'tokens' option
// in the options parameter, e.g.:
// new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });
// will incrementally autocomplete with a comma as the token.
// Additionally, ',' in the above example can be replaced with
// a token array, e.g. { tokens: [',', '\n'] } which
// enables autocompletion on multiple tokens. This is most
// useful when one of the tokens is \n (a newline), as it
// allows smart autocompletion after linebreaks.
var Autocompleter = {}
Autocompleter.Base = function() {};
Autocompleter.Base.prototype = {
baseInitialize: function(element, update, options) {
this.element = $(element);
this.update = $(update);
this.hasFocus = false;
this.changed = false;
this.active = false;
this.index = 0;
this.entryCount = 0;
if (this.setOptions)
this.setOptions(options);
else
this.options = options || {};
this.options.paramName = this.options.paramName || this.element.name;
this.options.tokens = this.options.tokens || [];
this.options.frequency = this.options.frequency || 0.4;
this.options.minChars = this.options.minChars || 1;
this.options.onShow = this.options.onShow ||
function(element, update){
if(!update.style.position || update.style.position=='absolute') {
update.style.position = 'absolute';
Position.clone(element, update, {setHeight: false, offsetTop: element.offsetHeight});
}
Effect.Appear(update,{duration:0.15});
};
this.options.onHide = this.options.onHide ||
function(element, update){ new Effect.Fade(update,{duration:0.15}) };
if (typeof(this.options.tokens) == 'string')
this.options.tokens = new Array(this.options.tokens);
this.observer = null;
this.element.setAttribute('autocomplete','off');
Element.hide(this.update);
Event.observe(this.element, "blur", this.onBlur.bindAsEventListener(this));
Event.observe(this.element, "keypress", this.onKeyPress.bindAsEventListener(this));
},
show: function() {
if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
if(!this.iefix &&
(navigator.appVersion.indexOf('MSIE')>0) &&
(navigator.userAgent.indexOf('Opera')<0) &&
(Element.getStyle(this.update, 'position')=='absolute')) {
new Insertion.After(this.update,
'<iframe id="' + this.update.id + '_iefix" '+
'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
this.iefix = $(this.update.id+'_iefix');
}
if(this.iefix) setTimeout(this.fixIEOverlapping.bind(this), 50);
},
fixIEOverlapping: function() {
Position.clone(this.update, this.iefix);
this.iefix.style.zIndex = 1;
this.update.style.zIndex = 2;
Element.show(this.iefix);
},
hide: function() {
this.stopIndicator();
if(Element.getStyle(this.update, 'display')!='none') this.options.onHide(this.element, this.update);
if(this.iefix) Element.hide(this.iefix);
},
startIndicator: function() {
if(this.options.indicator) Element.show(this.options.indicator);
},
stopIndicator: function() {
if(this.options.indicator) Element.hide(this.options.indicator);
},
onKeyPress: function(event) {
if(this.active)
switch(event.keyCode) {
case Event.KEY_TAB:
case Event.KEY_RETURN:
this.selectEntry();
Event.stop(event);
case Event.KEY_ESC:
this.hide();
this.active = false;
Event.stop(event);
return;
case Event.KEY_LEFT:
case Event.KEY_RIGHT:
return;
case Event.KEY_UP:
this.markPrevious();
this.render();
if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
return;
case Event.KEY_DOWN:
this.markNext();
this.render();
if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
return;
}
else
if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN ||
(navigator.appVersion.indexOf('AppleWebKit') > 0 && event.keyCode == 0)) return;
this.changed = true;
this.hasFocus = true;
if(this.observer) clearTimeout(this.observer);
this.observer =
setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);
},
activate: function() {
this.changed = false;
this.hasFocus = true;
this.getUpdatedChoices();
},
onHover: function(event) {
var element = Event.findElement(event, 'LI');
if(this.index != element.autocompleteIndex)
{
this.index = element.autocompleteIndex;
this.render();
}
Event.stop(event);
},
onClick: function(event) {
var element = Event.findElement(event, 'LI');
this.index = element.autocompleteIndex;
this.selectEntry();
this.hide();
},
onBlur: function(event) {
// needed to make click events working
setTimeout(this.hide.bind(this), 250);
this.hasFocus = false;
this.active = false;
},
render: function() {
if(this.entryCount > 0) {
for (var i = 0; i < this.entryCount; i++)
this.index==i ?
Element.addClassName(this.getEntry(i),"selected") :
Element.removeClassName(this.getEntry(i),"selected");
if(this.hasFocus) {
this.show();
this.active = true;
}
} else {
this.active = false;
this.hide();
}
},
markPrevious: function() {
if(this.index > 0) this.index--
else this.index = this.entryCount-1;
},
markNext: function() {
if(this.index < this.entryCount-1) this.index++
else this.index = 0;
},
getEntry: function(index) {
return this.update.firstChild.childNodes[index];
},
getCurrentEntry: function() {
return this.getEntry(this.index);
},
selectEntry: function() {
this.active = false;
this.updateElement(this.getCurrentEntry());
},
updateElement: function(selectedElement) {
if (this.options.updateElement) {
this.options.updateElement(selectedElement);
return;
}
var value = '';
if (this.options.select) {
var nodes = document.getElementsByClassName(this.options.select, selectedElement) || [];
if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);
} else
value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
var lastTokenPos = this.findLastToken();
if (lastTokenPos != -1) {
var newValue = this.element.value.substr(0, lastTokenPos + 1);
var whitespace = this.element.value.substr(lastTokenPos + 1).match(/^\s+/);
if (whitespace)
newValue += whitespace[0];
this.element.value = newValue + value;
} else {
this.element.value = value;
}
this.element.focus();
if (this.options.afterUpdateElement)
this.options.afterUpdateElement(this.element, selectedElement);
},
updateChoices: function(choices) {
if(!this.changed && this.hasFocus) {
this.update.innerHTML = choices;
Element.cleanWhitespace(this.update);
Element.cleanWhitespace(this.update.firstChild);
if(this.update.firstChild && this.update.firstChild.childNodes) {
this.entryCount =
this.update.firstChild.childNodes.length;
for (var i = 0; i < this.entryCount; i++) {
var entry = this.getEntry(i);
entry.autocompleteIndex = i;
this.addObservers(entry);
}
} else {
this.entryCount = 0;
}
this.stopIndicator();
this.index = 0;
this.render();
}
},
addObservers: function(element) {
Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));
Event.observe(element, "click", this.onClick.bindAsEventListener(this));
},
onObserverEvent: function() {
this.changed = false;
if(this.getToken().length>=this.options.minChars) {
this.startIndicator();
this.getUpdatedChoices();
} else {
this.active = false;
this.hide();
}
},
getToken: function() {
var tokenPos = this.findLastToken();
if (tokenPos != -1)
var ret = this.element.value.substr(tokenPos + 1).replace(/^\s+/,'').replace(/\s+$/,'');
else
var ret = this.element.value;
return /\n/.test(ret) ? '' : ret;
},
findLastToken: function() {
var lastTokenPos = -1;
for (var i=0; i<this.options.tokens.length; i++) {
var thisTokenPos = this.element.value.lastIndexOf(this.options.tokens[i]);
if (thisTokenPos > lastTokenPos)
lastTokenPos = thisTokenPos;
}
return lastTokenPos;
}
}
Ajax.Autocompleter = Class.create();
Object.extend(Object.extend(Ajax.Autocompleter.prototype, Autocompleter.Base.prototype), {
initialize: function(element, update, url, options) {
this.baseInitialize(element, update, options);
this.options.asynchronous = true;
this.options.onComplete = this.onComplete.bind(this);
this.options.defaultParams = this.options.parameters || null;
this.url = url;
},
getUpdatedChoices: function() {
entry = encodeURIComponent(this.options.paramName) + '=' +
encodeURIComponent(this.getToken());
this.options.parameters = this.options.callback ?
this.options.callback(this.element, entry) : entry;
if(this.options.defaultParams)
this.options.parameters += '&' + this.options.defaultParams;
new Ajax.Request(this.url, this.options);
},
onComplete: function(request) {
this.updateChoices(request.responseText);
}
});
// The local array autocompleter. Used when you'd prefer to
// inject an array of autocompletion options into the page, rather
// than sending out Ajax queries, which can be quite slow sometimes.
//
// The constructor takes four parameters. The first two are, as usual,
// the id of the monitored textbox, and id of the autocompletion menu.
// The third is the array you want to autocomplete from, and the fourth
// is the options block.
//
// Extra local autocompletion options:
// - choices - How many autocompletion choices to offer
//
// - partialSearch - If false, the autocompleter will match entered
// text only at the beginning of strings in the
// autocomplete array. Defaults to true, which will
// match text at the beginning of any *word* in the
// strings in the autocomplete array. If you want to
// search anywhere in the string, additionally set
// the option fullSearch to true (default: off).
//
// - fullSsearch - Search anywhere in autocomplete array strings.
//
// - partialChars - How many characters to enter before triggering
// a partial match (unlike minChars, which defines
// how many characters are required to do any match
// at all). Defaults to 2.
//
// - ignoreCase - Whether to ignore case when autocompleting.
// Defaults to true.
//
// It's possible to pass in a custom function as the 'selector'
// option, if you prefer to write your own autocompletion logic.
// In that case, the other options above will not apply unless
// you support them.
Autocompleter.Local = Class.create();
Autocompleter.Local.prototype = Object.extend(new Autocompleter.Base(), {
initialize: function(element, update, array, options) {
this.baseInitialize(element, update, options);
this.options.array = array;
},
getUpdatedChoices: function() {
this.updateChoices(this.options.selector(this));
},
setOptions: function(options) {
this.options = Object.extend({
choices: 10,
partialSearch: true,
partialChars: 2,
ignoreCase: true,
fullSearch: false,
selector: function(instance) {
var ret = []; // Beginning matches
var partial = []; // Inside matches
var entry = instance.getToken();
var count = 0;
for (var i = 0; i < instance.options.array.length &&
ret.length < instance.options.choices ; i++) {
var elem = instance.options.array[i];
var foundPos = instance.options.ignoreCase ?
elem.toLowerCase().indexOf(entry.toLowerCase()) :
elem.indexOf(entry);
while (foundPos != -1) {
if (foundPos == 0 && elem.length != entry.length) {
ret.push("<li><strong>" + elem.substr(0, entry.length) + "</strong>" +
elem.substr(entry.length) + "</li>");
break;
} else if (entry.length >= instance.options.partialChars &&
instance.options.partialSearch && foundPos != -1) {
if (instance.options.fullSearch || /\s/.test(elem.substr(foundPos-1,1))) {
partial.push("<li>" + elem.substr(0, foundPos) + "<strong>" +
elem.substr(foundPos, entry.length) + "</strong>" + elem.substr(
foundPos + entry.length) + "</li>");
break;
}
}
foundPos = instance.options.ignoreCase ?
elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) :
elem.indexOf(entry, foundPos + 1);
}
}
if (partial.length)
ret = ret.concat(partial.slice(0, instance.options.choices - ret.length))
return "<ul>" + ret.join('') + "</ul>";
}
}, options || {});
}
});
// AJAX in-place editor
//
// see documentation on http://wiki.script.aculo.us/scriptaculous/show/Ajax.InPlaceEditor
// Use this if you notice weird scrolling problems on some browsers,
// the DOM might be a bit confused when this gets called so do this
// waits 1 ms (with setTimeout) until it does the activation
Field.scrollFreeActivate = function(field) {
setTimeout(function() {
Field.activate(field);
}, 1);
}
Ajax.InPlaceEditor = Class.create();
Ajax.InPlaceEditor.defaultHighlightColor = "#FFFF99";
Ajax.InPlaceEditor.prototype = {
initialize: function(element, url, options) {
this.url = url;
this.element = $(element);
this.options = Object.extend({
okButton: true,
okText: "ok",
cancelLink: true,
cancelText: "cancel",
savingText: "Saving...",
clickToEditText: "Click to edit",
okText: "ok",
rows: 1,
onComplete: function(transport, element) {
new Effect.Highlight(element, {startcolor: this.options.highlightcolor});
},
onFailure: function(transport) {
alert("Error communicating with the server: " + transport.responseText.stripTags());
},
callback: function(form) {
return Form.serialize(form);
},
handleLineBreaks: true,
loadingText: 'Loading...',
savingClassName: 'inplaceeditor-saving',
loadingClassName: 'inplaceeditor-loading',
formClassName: 'inplaceeditor-form',
highlightcolor: Ajax.InPlaceEditor.defaultHighlightColor,
highlightendcolor: "#FFFFFF",
externalControl: null,
submitOnBlur: false,
ajaxOptions: {},
evalScripts: false
}, options || {});
if(!this.options.formId && this.element.id) {
this.options.formId = this.element.id + "-inplaceeditor";
if ($(this.options.formId)) {
// there's already a form with that name, don't specify an id
this.options.formId = null;
}
}
if (this.options.externalControl) {
this.options.externalControl = $(this.options.externalControl);
}
this.originalBackground = Element.getStyle(this.element, 'background-color');
if (!this.originalBackground) {
this.originalBackground = "transparent";
}
this.element.title = this.options.clickToEditText;
this.onclickListener = this.enterEditMode.bindAsEventListener(this);
this.mouseoverListener = this.enterHover.bindAsEventListener(this);
this.mouseoutListener = this.leaveHover.bindAsEventListener(this);
Event.observe(this.element, 'click', this.onclickListener);
Event.observe(this.element, 'mouseover', this.mouseoverListener);
Event.observe(this.element, 'mouseout', this.mouseoutListener);
if (this.options.externalControl) {
Event.observe(this.options.externalControl, 'click', this.onclickListener);
Event.observe(this.options.externalControl, 'mouseover', this.mouseoverListener);
Event.observe(this.options.externalControl, 'mouseout', this.mouseoutListener);
}
},
enterEditMode: function(evt) {
if (this.saving) return;
if (this.editing) return;
this.editing = true;
this.onEnterEditMode();
if (this.options.externalControl) {
Element.hide(this.options.externalControl);
}
Element.hide(this.element);
this.createForm();
this.element.parentNode.insertBefore(this.form, this.element);
Field.scrollFreeActivate(this.editField);
// stop the event to avoid a page refresh in Safari
if (evt) {
Event.stop(evt);
}
return false;
},
createForm: function() {
this.form = document.createElement("form");
this.form.id = this.options.formId;
Element.addClassName(this.form, this.options.formClassName)
this.form.onsubmit = this.onSubmit.bind(this);
this.createEditField();
if (this.options.textarea) {
var br = document.createElement("br");
this.form.appendChild(br);
}
if (this.options.okButton) {
okButton = document.createElement("input");
okButton.type = "submit";
okButton.value = this.options.okText;
okButton.className = 'editor_ok_button';
this.form.appendChild(okButton);
}
if (this.options.cancelLink) {
cancelLink = document.createElement("a");
cancelLink.href = "#";
cancelLink.appendChild(document.createTextNode(this.options.cancelText));
cancelLink.onclick = this.onclickCancel.bind(this);
cancelLink.className = 'editor_cancel';
this.form.appendChild(cancelLink);
}
},
hasHTMLLineBreaks: function(string) {
if (!this.options.handleLineBreaks) return false;
return string.match(/<br/i) || string.match(/<p>/i);
},
convertHTMLLineBreaks: function(string) {
return string.replace(/<br>/gi, "\n").replace(/<br\/>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<p>/gi, "");
},
createEditField: function() {
var text;
if(this.options.loadTextURL) {
text = this.options.loadingText;
} else {
text = this.getText();
}
var obj = this;
if (this.options.rows == 1 && !this.hasHTMLLineBreaks(text)) {
this.options.textarea = false;
var textField = document.createElement("input");
textField.obj = this;
textField.type = "text";
textField.name = "value";
textField.value = text;
textField.style.backgroundColor = this.options.highlightcolor;
textField.className = 'editor_field';
var size = this.options.size || this.options.cols || 0;
if (size != 0) textField.size = size;
if (this.options.submitOnBlur)
textField.onblur = this.onSubmit.bind(this);
this.editField = textField;
} else {
this.options.textarea = true;
var textArea = document.createElement("textarea");
textArea.obj = this;
textArea.name = "value";
textArea.value = this.convertHTMLLineBreaks(text);
textArea.rows = this.options.rows;
textArea.cols = this.options.cols || 40;
textArea.className = 'editor_field';
if (this.options.submitOnBlur)
textArea.onblur = this.onSubmit.bind(this);
this.editField = textArea;
}
if(this.options.loadTextURL) {
this.loadExternalText();
}
this.form.appendChild(this.editField);
},
getText: function() {
return this.element.innerHTML;
},
loadExternalText: function() {
Element.addClassName(this.form, this.options.loadingClassName);
this.editField.disabled = true;
new Ajax.Request(
this.options.loadTextURL,
Object.extend({
asynchronous: true,
onComplete: this.onLoadedExternalText.bind(this)
}, this.options.ajaxOptions)
);
},
onLoadedExternalText: function(transport) {
Element.removeClassName(this.form, this.options.loadingClassName);
this.editField.disabled = false;
this.editField.value = transport.responseText.stripTags();
},
onclickCancel: function() {
this.onComplete();
this.leaveEditMode();
return false;
},
onFailure: function(transport) {
this.options.onFailure(transport);
if (this.oldInnerHTML) {
this.element.innerHTML = this.oldInnerHTML;
this.oldInnerHTML = null;
}
return false;
},
onSubmit: function() {
// onLoading resets these so we need to save them away for the Ajax call
var form = this.form;
var value = this.editField.value;
// do this first, sometimes the ajax call returns before we get a chance to switch on Saving...
// which means this will actually switch on Saving... *after* we've left edit mode causing Saving...
// to be displayed indefinitely
this.onLoading();
if (this.options.evalScripts) {
new Ajax.Request(
this.url, Object.extend({
parameters: this.options.callback(form, value),
onComplete: this.onComplete.bind(this),
onFailure: this.onFailure.bind(this),
asynchronous:true,
evalScripts:true
}, this.options.ajaxOptions));
} else {
new Ajax.Updater(
{ success: this.element,
// don't update on failure (this could be an option)
failure: null },
this.url, Object.extend({
parameters: this.options.callback(form, value),
onComplete: this.onComplete.bind(this),
onFailure: this.onFailure.bind(this)
}, this.options.ajaxOptions));
}
// stop the event to avoid a page refresh in Safari
if (arguments.length > 1) {
Event.stop(arguments[0]);
}
return false;
},
onLoading: function() {
this.saving = true;
this.removeForm();
this.leaveHover();
this.showSaving();
},
showSaving: function() {
this.oldInnerHTML = this.element.innerHTML;
this.element.innerHTML = this.options.savingText;
Element.addClassName(this.element, this.options.savingClassName);
this.element.style.backgroundColor = this.originalBackground;
Element.show(this.element);
},
removeForm: function() {
if(this.form) {
if (this.form.parentNode) Element.remove(this.form);
this.form = null;
}
},
enterHover: function() {
if (this.saving) return;
this.element.style.backgroundColor = this.options.highlightcolor;
if (this.effect) {
this.effect.cancel();
}
Element.addClassName(this.element, this.options.hoverClassName)
},
leaveHover: function() {
if (this.options.backgroundColor) {
this.element.style.backgroundColor = this.oldBackground;
}
Element.removeClassName(this.element, this.options.hoverClassName)
if (this.saving) return;
this.effect = new Effect.Highlight(this.element, {
startcolor: this.options.highlightcolor,
endcolor: this.options.highlightendcolor,
restorecolor: this.originalBackground
});
},
leaveEditMode: function() {
Element.removeClassName(this.element, this.options.savingClassName);
this.removeForm();
this.leaveHover();
this.element.style.backgroundColor = this.originalBackground;
Element.show(this.element);
if (this.options.externalControl) {
Element.show(this.options.externalControl);
}
this.editing = false;
this.saving = false;
this.oldInnerHTML = null;
this.onLeaveEditMode();
},
onComplete: function(transport) {
this.leaveEditMode();
this.options.onComplete.bind(this)(transport, this.element);
},
onEnterEditMode: function() {},
onLeaveEditMode: function() {},
dispose: function() {
if (this.oldInnerHTML) {
this.element.innerHTML = this.oldInnerHTML;
}
this.leaveEditMode();
Event.stopObserving(this.element, 'click', this.onclickListener);
Event.stopObserving(this.element, 'mouseover', this.mouseoverListener);
Event.stopObserving(this.element, 'mouseout', this.mouseoutListener);
if (this.options.externalControl) {
Event.stopObserving(this.options.externalControl, 'click', this.onclickListener);
Event.stopObserving(this.options.externalControl, 'mouseover', this.mouseoverListener);
Event.stopObserving(this.options.externalControl, 'mouseout', this.mouseoutListener);
}
}
};
Ajax.InPlaceCollectionEditor = Class.create();
Object.extend(Ajax.InPlaceCollectionEditor.prototype, Ajax.InPlaceEditor.prototype);
Object.extend(Ajax.InPlaceCollectionEditor.prototype, {
createEditField: function() {
if (!this.cached_selectTag) {
var selectTag = document.createElement("select");
var collection = this.options.collection || [];
var optionTag;
collection.each(function(e,i) {
optionTag = document.createElement("option");
optionTag.value = (e instanceof Array) ? e[0] : e;
if(this.options.value==optionTag.value) optionTag.selected = true;
optionTag.appendChild(document.createTextNode((e instanceof Array) ? e[1] : e));
selectTag.appendChild(optionTag);
}.bind(this));
this.cached_selectTag = selectTag;
}
this.editField = this.cached_selectTag;
if(this.options.loadTextURL) this.loadExternalText();
this.form.appendChild(this.editField);
this.options.callback = function(form, value) {
return "value=" + encodeURIComponent(value);
}
}
});
// Delayed observer, like Form.Element.Observer,
// but waits for delay after last key input
// Ideal for live-search fields
Form.Element.DelayedObserver = Class.create();
Form.Element.DelayedObserver.prototype = {
initialize: function(element, delay, callback) {
this.delay = delay || 0.5;
this.element = $(element);
this.callback = callback;
this.timer = null;
this.lastValue = $F(this.element);
Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
},
delayedListener: function(event) {
if(this.lastValue == $F(this.element)) return;
if(this.timer) clearTimeout(this.timer);
this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
this.lastValue = $F(this.element);
},
onTimerEvent: function() {
this.timer = null;
this.callback(this.element, $F(this.element));
}
};

913
vendor/plugins/asset_packager/test/assets/javascripts/dragdrop.js vendored
View file

@ -1,913 +0,0 @@
// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// (c) 2005 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
//
// See scriptaculous.js for full license.
/*--------------------------------------------------------------------------*/
var Droppables = {
drops: [],
remove: function(element) {
this.drops = this.drops.reject(function(d) { return d.element==$(element) });
},
add: function(element) {
element = $(element);
var options = Object.extend({
greedy: true,
hoverclass: null,
tree: false
}, arguments[1] || {});
// cache containers
if(options.containment) {
options._containers = [];
var containment = options.containment;
if((typeof containment == 'object') &&
(containment.constructor == Array)) {
containment.each( function(c) { options._containers.push($(c)) });
} else {
options._containers.push($(containment));
}
}
if(options.accept) options.accept = [options.accept].flatten();
Element.makePositioned(element); // fix IE
options.element = element;
this.drops.push(options);
},
findDeepestChild: function(drops) {
deepest = drops[0];
for (i = 1; i < drops.length; ++i)
if (Element.isParent(drops[i].element, deepest.element))
deepest = drops[i];
return deepest;
},
isContained: function(element, drop) {
var containmentNode;
if(drop.tree) {
containmentNode = element.treeNode;
} else {
containmentNode = element.parentNode;
}
return drop._containers.detect(function(c) { return containmentNode == c });
},
isAffected: function(point, element, drop) {
return (
(drop.element!=element) &&
((!drop._containers) ||
this.isContained(element, drop)) &&
((!drop.accept) ||
(Element.classNames(element).detect(
function(v) { return drop.accept.include(v) } ) )) &&
Position.within(drop.element, point[0], point[1]) );
},
deactivate: function(drop) {
if(drop.hoverclass)
Element.removeClassName(drop.element, drop.hoverclass);
this.last_active = null;
},
activate: function(drop) {
if(drop.hoverclass)
Element.addClassName(drop.element, drop.hoverclass);
this.last_active = drop;
},
show: function(point, element) {
if(!this.drops.length) return;
var affected = [];
if(this.last_active) this.deactivate(this.last_active);
this.drops.each( function(drop) {
if(Droppables.isAffected(point, element, drop))
affected.push(drop);
});
if(affected.length>0) {
drop = Droppables.findDeepestChild(affected);
Position.within(drop.element, point[0], point[1]);
if(drop.onHover)
drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
Droppables.activate(drop);
}
},
fire: function(event, element) {
if(!this.last_active) return;
Position.prepare();
if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
if (this.last_active.onDrop)
this.last_active.onDrop(element, this.last_active.element, event);
},
reset: function() {
if(this.last_active)
this.deactivate(this.last_active);
}
}
var Draggables = {
drags: [],
observers: [],
register: function(draggable) {
if(this.drags.length == 0) {
this.eventMouseUp = this.endDrag.bindAsEventListener(this);
this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
this.eventKeypress = this.keyPress.bindAsEventListener(this);
Event.observe(document, "mouseup", this.eventMouseUp);
Event.observe(document, "mousemove", this.eventMouseMove);
Event.observe(document, "keypress", this.eventKeypress);
}
this.drags.push(draggable);
},
unregister: function(draggable) {
this.drags = this.drags.reject(function(d) { return d==draggable });
if(this.drags.length == 0) {
Event.stopObserving(document, "mouseup", this.eventMouseUp);
Event.stopObserving(document, "mousemove", this.eventMouseMove);
Event.stopObserving(document, "keypress", this.eventKeypress);
}
},
activate: function(draggable) {
window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
this.activeDraggable = draggable;
},
deactivate: function() {
this.activeDraggable = null;
},
updateDrag: function(event) {
if(!this.activeDraggable) return;
var pointer = [Event.pointerX(event), Event.pointerY(event)];
// Mozilla-based browsers fire successive mousemove events with
// the same coordinates, prevent needless redrawing (moz bug?)
if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
this._lastPointer = pointer;
this.activeDraggable.updateDrag(event, pointer);
},
endDrag: function(event) {
if(!this.activeDraggable) return;
this._lastPointer = null;
this.activeDraggable.endDrag(event);
this.activeDraggable = null;
},
keyPress: function(event) {
if(this.activeDraggable)
this.activeDraggable.keyPress(event);
},
addObserver: function(observer) {
this.observers.push(observer);
this._cacheObserverCallbacks();
},
removeObserver: function(element) { // element instead of observer fixes mem leaks
this.observers = this.observers.reject( function(o) { return o.element==element });
this._cacheObserverCallbacks();
},
notify: function(eventName, draggable, event) { // 'onStart', 'onEnd', 'onDrag'
if(this[eventName+'Count'] > 0)
this.observers.each( function(o) {
if(o[eventName]) o[eventName](eventName, draggable, event);
});
},
_cacheObserverCallbacks: function() {
['onStart','onEnd','onDrag'].each( function(eventName) {
Draggables[eventName+'Count'] = Draggables.observers.select(
function(o) { return o[eventName]; }
).length;
});
}
}
/*--------------------------------------------------------------------------*/
var Draggable = Class.create();
Draggable.prototype = {
initialize: function(element) {
var options = Object.extend({
handle: false,
starteffect: function(element) {
new Effect.Opacity(element, {duration:0.2, from:1.0, to:0.7});
},
reverteffect: function(element, top_offset, left_offset) {
var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
element._revert = new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur});
},
endeffect: function(element) {
new Effect.Opacity(element, {duration:0.2, from:0.7, to:1.0});
},
zindex: 1000,
revert: false,
scroll: false,
scrollSensitivity: 20,
scrollSpeed: 15,
snap: false // false, or xy or [x,y] or function(x,y){ return [x,y] }
}, arguments[1] || {});
this.element = $(element);
if(options.handle && (typeof options.handle == 'string')) {
var h = Element.childrenWithClassName(this.element, options.handle, true);
if(h.length>0) this.handle = h[0];
}
if(!this.handle) this.handle = $(options.handle);
if(!this.handle) this.handle = this.element;
if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML)
options.scroll = $(options.scroll);
Element.makePositioned(this.element); // fix IE
this.delta = this.currentDelta();
this.options = options;
this.dragging = false;
this.eventMouseDown = this.initDrag.bindAsEventListener(this);
Event.observe(this.handle, "mousedown", this.eventMouseDown);
Draggables.register(this);
},
destroy: function() {
Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
Draggables.unregister(this);
},
currentDelta: function() {
return([
parseInt(Element.getStyle(this.element,'left') || '0'),
parseInt(Element.getStyle(this.element,'top') || '0')]);
},
initDrag: function(event) {
if(Event.isLeftClick(event)) {
// abort on form elements, fixes a Firefox issue
var src = Event.element(event);
if(src.tagName && (
src.tagName=='INPUT' ||
src.tagName=='SELECT' ||
src.tagName=='OPTION' ||
src.tagName=='BUTTON' ||
src.tagName=='TEXTAREA')) return;
if(this.element._revert) {
this.element._revert.cancel();
this.element._revert = null;
}
var pointer = [Event.pointerX(event), Event.pointerY(event)];
var pos = Position.cumulativeOffset(this.element);
this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });
Draggables.activate(this);
Event.stop(event);
}
},
startDrag: function(event) {
this.dragging = true;
if(this.options.zindex) {
this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
this.element.style.zIndex = this.options.zindex;
}
if(this.options.ghosting) {
this._clone = this.element.cloneNode(true);
Position.absolutize(this.element);
this.element.parentNode.insertBefore(this._clone, this.element);
}
if(this.options.scroll) {
if (this.options.scroll == window) {
var where = this._getWindowScroll(this.options.scroll);
this.originalScrollLeft = where.left;
this.originalScrollTop = where.top;
} else {
this.originalScrollLeft = this.options.scroll.scrollLeft;
this.originalScrollTop = this.options.scroll.scrollTop;
}
}
Draggables.notify('onStart', this, event);
if(this.options.starteffect) this.options.starteffect(this.element);
},
updateDrag: function(event, pointer) {
if(!this.dragging) this.startDrag(event);
Position.prepare();
Droppables.show(pointer, this.element);
Draggables.notify('onDrag', this, event);
this.draw(pointer);
if(this.options.change) this.options.change(this);
if(this.options.scroll) {
this.stopScrolling();
var p;
if (this.options.scroll == window) {
with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
} else {
p = Position.page(this.options.scroll);
p[0] += this.options.scroll.scrollLeft;
p[1] += this.options.scroll.scrollTop;
p.push(p[0]+this.options.scroll.offsetWidth);
p.push(p[1]+this.options.scroll.offsetHeight);
}
var speed = [0,0];
if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
this.startScrolling(speed);
}
// fix AppleWebKit rendering
if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
Event.stop(event);
},
finishDrag: function(event, success) {
this.dragging = false;
if(this.options.ghosting) {
Position.relativize(this.element);
Element.remove(this._clone);
this._clone = null;
}
if(success) Droppables.fire(event, this.element);
Draggables.notify('onEnd', this, event);
var revert = this.options.revert;
if(revert && typeof revert == 'function') revert = revert(this.element);
var d = this.currentDelta();
if(revert && this.options.reverteffect) {
this.options.reverteffect(this.element,
d[1]-this.delta[1], d[0]-this.delta[0]);
} else {
this.delta = d;
}
if(this.options.zindex)
this.element.style.zIndex = this.originalZ;
if(this.options.endeffect)
this.options.endeffect(this.element);
Draggables.deactivate(this);
Droppables.reset();
},
keyPress: function(event) {
if(event.keyCode!=Event.KEY_ESC) return;
this.finishDrag(event, false);
Event.stop(event);
},
endDrag: function(event) {
if(!this.dragging) return;
this.stopScrolling();
this.finishDrag(event, true);
Event.stop(event);
},
draw: function(point) {
var pos = Position.cumulativeOffset(this.element);
var d = this.currentDelta();
pos[0] -= d[0]; pos[1] -= d[1];
if(this.options.scroll && (this.options.scroll != window)) {
pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
}
var p = [0,1].map(function(i){
return (point[i]-pos[i]-this.offset[i])
}.bind(this));
if(this.options.snap) {
if(typeof this.options.snap == 'function') {
p = this.options.snap(p[0],p[1]);
} else {
if(this.options.snap instanceof Array) {
p = p.map( function(v, i) {
return Math.round(v/this.options.snap[i])*this.options.snap[i] }.bind(this))
} else {
p = p.map( function(v) {
return Math.round(v/this.options.snap)*this.options.snap }.bind(this))
}
}}
var style = this.element.style;
if((!this.options.constraint) || (this.options.constraint=='horizontal'))
style.left = p[0] + "px";
if((!this.options.constraint) || (this.options.constraint=='vertical'))
style.top = p[1] + "px";
if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
},
stopScrolling: function() {
if(this.scrollInterval) {
clearInterval(this.scrollInterval);
this.scrollInterval = null;
Draggables._lastScrollPointer = null;
}
},
startScrolling: function(speed) {
this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
this.lastScrolled = new Date();
this.scrollInterval = setInterval(this.scroll.bind(this), 10);
},
scroll: function() {
var current = new Date();
var delta = current - this.lastScrolled;
this.lastScrolled = current;
if(this.options.scroll == window) {
with (this._getWindowScroll(this.options.scroll)) {
if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
var d = delta / 1000;
this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
}
}
} else {
this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
}
Position.prepare();
Droppables.show(Draggables._lastPointer, this.element);
Draggables.notify('onDrag', this);
Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
if (Draggables._lastScrollPointer[0] < 0)
Draggables._lastScrollPointer[0] = 0;
if (Draggables._lastScrollPointer[1] < 0)
Draggables._lastScrollPointer[1] = 0;
this.draw(Draggables._lastScrollPointer);
if(this.options.change) this.options.change(this);
},
_getWindowScroll: function(w) {
var T, L, W, H;
with (w.document) {
if (w.document.documentElement && documentElement.scrollTop) {
T = documentElement.scrollTop;
L = documentElement.scrollLeft;
} else if (w.document.body) {
T = body.scrollTop;
L = body.scrollLeft;
}
if (w.innerWidth) {
W = w.innerWidth;
H = w.innerHeight;
} else if (w.document.documentElement && documentElement.clientWidth) {
W = documentElement.clientWidth;
H = documentElement.clientHeight;
} else {
W = body.offsetWidth;
H = body.offsetHeight
}
}
return { top: T, left: L, width: W, height: H };
}
}
/*--------------------------------------------------------------------------*/
var SortableObserver = Class.create();
SortableObserver.prototype = {
initialize: function(element, observer) {
this.element = $(element);
this.observer = observer;
this.lastValue = Sortable.serialize(this.element);
},
onStart: function() {
this.lastValue = Sortable.serialize(this.element);
},
onEnd: function() {
Sortable.unmark();
if(this.lastValue != Sortable.serialize(this.element))
this.observer(this.element)
}
}
var Sortable = {
sortables: {},
_findRootElement: function(element) {
while (element.tagName != "BODY") {
if(element.id && Sortable.sortables[element.id]) return element;
element = element.parentNode;
}
},
options: function(element) {
element = Sortable._findRootElement($(element));
if(!element) return;
return Sortable.sortables[element.id];
},
destroy: function(element){
var s = Sortable.options(element);
if(s) {
Draggables.removeObserver(s.element);
s.droppables.each(function(d){ Droppables.remove(d) });
s.draggables.invoke('destroy');
delete Sortable.sortables[s.element.id];
}
},
create: function(element) {
element = $(element);
var options = Object.extend({
element: element,
tag: 'li', // assumes li children, override with tag: 'tagname'
dropOnEmpty: false,
tree: false,
treeTag: 'ul',
overlap: 'vertical', // one of 'vertical', 'horizontal'
constraint: 'vertical', // one of 'vertical', 'horizontal', false
containment: element, // also takes array of elements (or id's); or false
handle: false, // or a CSS class
only: false,
hoverclass: null,
ghosting: false,
scroll: false,
scrollSensitivity: 20,
scrollSpeed: 15,
format: /^[^_]*_(.*)$/,
onChange: Prototype.emptyFunction,
onUpdate: Prototype.emptyFunction
}, arguments[1] || {});
// clear any old sortable with same element
this.destroy(element);
// build options for the draggables
var options_for_draggable = {
revert: true,
scroll: options.scroll,
scrollSpeed: options.scrollSpeed,
scrollSensitivity: options.scrollSensitivity,
ghosting: options.ghosting,
constraint: options.constraint,
handle: options.handle };
if(options.starteffect)
options_for_draggable.starteffect = options.starteffect;
if(options.reverteffect)
options_for_draggable.reverteffect = options.reverteffect;
else
if(options.ghosting) options_for_draggable.reverteffect = function(element) {
element.style.top = 0;
element.style.left = 0;
};
if(options.endeffect)
options_for_draggable.endeffect = options.endeffect;
if(options.zindex)
options_for_draggable.zindex = options.zindex;
// build options for the droppables
var options_for_droppable = {
overlap: options.overlap,
containment: options.containment,
tree: options.tree,
hoverclass: options.hoverclass,
onHover: Sortable.onHover
//greedy: !options.dropOnEmpty
}
var options_for_tree = {
onHover: Sortable.onEmptyHover,
overlap: options.overlap,
containment: options.containment,
hoverclass: options.hoverclass
}
// fix for gecko engine
Element.cleanWhitespace(element);
options.draggables = [];
options.droppables = [];
// drop on empty handling
if(options.dropOnEmpty || options.tree) {
Droppables.add(element, options_for_tree);
options.droppables.push(element);
}
(this.findElements(element, options) || []).each( function(e) {
// handles are per-draggable
var handle = options.handle ?
Element.childrenWithClassName(e, options.handle)[0] : e;
options.draggables.push(
new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
Droppables.add(e, options_for_droppable);
if(options.tree) e.treeNode = element;
options.droppables.push(e);
});
if(options.tree) {
(Sortable.findTreeElements(element, options) || []).each( function(e) {
Droppables.add(e, options_for_tree);
e.treeNode = element;
options.droppables.push(e);
});
}
// keep reference
this.sortables[element.id] = options;
// for onupdate
Draggables.addObserver(new SortableObserver(element, options.onUpdate));
},
// return all suitable-for-sortable elements in a guaranteed order
findElements: function(element, options) {
return Element.findChildren(
element, options.only, options.tree ? true : false, options.tag);
},
findTreeElements: function(element, options) {
return Element.findChildren(
element, options.only, options.tree ? true : false, options.treeTag);
},
onHover: function(element, dropon, overlap) {
if(Element.isParent(dropon, element)) return;
if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
return;
} else if(overlap>0.5) {
Sortable.mark(dropon, 'before');
if(dropon.previousSibling != element) {
var oldParentNode = element.parentNode;
element.style.visibility = "hidden"; // fix gecko rendering
dropon.parentNode.insertBefore(element, dropon);
if(dropon.parentNode!=oldParentNode)
Sortable.options(oldParentNode).onChange(element);
Sortable.options(dropon.parentNode).onChange(element);
}
} else {
Sortable.mark(dropon, 'after');
var nextElement = dropon.nextSibling || null;
if(nextElement != element) {
var oldParentNode = element.parentNode;
element.style.visibility = "hidden"; // fix gecko rendering
dropon.parentNode.insertBefore(element, nextElement);
if(dropon.parentNode!=oldParentNode)
Sortable.options(oldParentNode).onChange(element);
Sortable.options(dropon.parentNode).onChange(element);
}
}
},
onEmptyHover: function(element, dropon, overlap) {
var oldParentNode = element.parentNode;
var droponOptions = Sortable.options(dropon);
if(!Element.isParent(dropon, element)) {
var index;
var children = Sortable.findElements(dropon, {tag: droponOptions.tag});
var child = null;
if(children) {
var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
for (index = 0; index < children.length; index += 1) {
if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
offset -= Element.offsetSize (children[index], droponOptions.overlap);
} else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
child = index + 1 < children.length ? children[index + 1] : null;
break;
} else {
child = children[index];
break;
}
}
}
dropon.insertBefore(element, child);
Sortable.options(oldParentNode).onChange(element);
droponOptions.onChange(element);
}
},
unmark: function() {
if(Sortable._marker) Element.hide(Sortable._marker);
},
mark: function(dropon, position) {
// mark on ghosting only
var sortable = Sortable.options(dropon.parentNode);
if(sortable && !sortable.ghosting) return;
if(!Sortable._marker) {
Sortable._marker = $('dropmarker') || document.createElement('DIV');
Element.hide(Sortable._marker);
Element.addClassName(Sortable._marker, 'dropmarker');
Sortable._marker.style.position = 'absolute';
document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
}
var offsets = Position.cumulativeOffset(dropon);
Sortable._marker.style.left = offsets[0] + 'px';
Sortable._marker.style.top = offsets[1] + 'px';
if(position=='after')
if(sortable.overlap == 'horizontal')
Sortable._marker.style.left = (offsets[0]+dropon.clientWidth) + 'px';
else
Sortable._marker.style.top = (offsets[1]+dropon.clientHeight) + 'px';
Element.show(Sortable._marker);
},
_tree: function(element, options, parent) {
var children = Sortable.findElements(element, options) || [];
for (var i = 0; i < children.length; ++i) {
var match = children[i].id.match(options.format);
if (!match) continue;
var child = {
id: encodeURIComponent(match ? match[1] : null),
element: element,
parent: parent,
children: new Array,
position: parent.children.length,
container: Sortable._findChildrenElement(children[i], options.treeTag.toUpperCase())
}
/* Get the element containing the children and recurse over it */
if (child.container)
this._tree(child.container, options, child)
parent.children.push (child);
}
return parent;
},
/* Finds the first element of the given tag type within a parent element.
Used for finding the first LI[ST] within a L[IST]I[TEM].*/
_findChildrenElement: function (element, containerTag) {
if (element && element.hasChildNodes)
for (var i = 0; i < element.childNodes.length; ++i)
if (element.childNodes[i].tagName == containerTag)
return element.childNodes[i];
return null;
},
tree: function(element) {
element = $(element);
var sortableOptions = this.options(element);
var options = Object.extend({
tag: sortableOptions.tag,
treeTag: sortableOptions.treeTag,
only: sortableOptions.only,
name: element.id,
format: sortableOptions.format
}, arguments[1] || {});
var root = {
id: null,
parent: null,
children: new Array,
container: element,
position: 0
}
return Sortable._tree (element, options, root);
},
/* Construct a [i] index for a particular node */
_constructIndex: function(node) {
var index = '';
do {
if (node.id) index = '[' + node.position + ']' + index;
} while ((node = node.parent) != null);
return index;
},
sequence: function(element) {
element = $(element);
var options = Object.extend(this.options(element), arguments[1] || {});
return $(this.findElements(element, options) || []).map( function(item) {
return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
});
},
setSequence: function(element, new_sequence) {
element = $(element);
var options = Object.extend(this.options(element), arguments[2] || {});
var nodeMap = {};
this.findElements(element, options).each( function(n) {
if (n.id.match(options.format))
nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
n.parentNode.removeChild(n);
});
new_sequence.each(function(ident) {
var n = nodeMap[ident];
if (n) {
n[1].appendChild(n[0]);
delete nodeMap[ident];
}
});
},
serialize: function(element) {
element = $(element);
var options = Object.extend(Sortable.options(element), arguments[1] || {});
var name = encodeURIComponent(
(arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
if (options.tree) {
return Sortable.tree(element, arguments[1]).children.map( function (item) {
return [name + Sortable._constructIndex(item) + "=" +
encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
}).flatten().join('&');
} else {
return Sortable.sequence(element, arguments[1]).map( function(item) {
return name + "[]=" + encodeURIComponent(item);
}).join('&');
}
}
}
/* Returns true if child is contained within element */
Element.isParent = function(child, element) {
if (!child.parentNode || child == element) return false;
if (child.parentNode == element) return true;
return Element.isParent(child.parentNode, element);
}
Element.findChildren = function(element, only, recursive, tagName) {
if(!element.hasChildNodes()) return null;
tagName = tagName.toUpperCase();
if(only) only = [only].flatten();
var elements = [];
$A(element.childNodes).each( function(e) {
if(e.tagName && e.tagName.toUpperCase()==tagName &&
(!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
elements.push(e);
if(recursive) {
var grandchildren = Element.findChildren(e, only, recursive, tagName);
if(grandchildren) elements.push(grandchildren);
}
});
return (elements.length>0 ? elements.flatten() : []);
}
Element.offsetSize = function (element, type) {
if (type == 'vertical' || type == 'height')
return element.offsetHeight;
else
return element.offsetWidth;
}

958
vendor/plugins/asset_packager/test/assets/javascripts/effects.js vendored
View file

@ -1,958 +0,0 @@
// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// Contributors:
// Justin Palmer (http://encytemedia.com/)
// Mark Pilgrim (http://diveintomark.org/)
// Martin Bialasinki
//
// See scriptaculous.js for full license.
// converts rgb() and #xxx to #xxxxxx format,
// returns self (or first argument) if not convertable
String.prototype.parseColor = function() {
var color = '#';
if(this.slice(0,4) == 'rgb(') {
var cols = this.slice(4,this.length-1).split(',');
var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);
} else {
if(this.slice(0,1) == '#') {
if(this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();
if(this.length==7) color = this.toLowerCase();
}
}
return(color.length==7 ? color : (arguments[0] || this));
}
/*--------------------------------------------------------------------------*/
Element.collectTextNodes = function(element) {
return $A($(element).childNodes).collect( function(node) {
return (node.nodeType==3 ? node.nodeValue :
(node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
}).flatten().join('');
}
Element.collectTextNodesIgnoreClass = function(element, className) {
return $A($(element).childNodes).collect( function(node) {
return (node.nodeType==3 ? node.nodeValue :
((node.hasChildNodes() && !Element.hasClassName(node,className)) ?
Element.collectTextNodesIgnoreClass(node, className) : ''));
}).flatten().join('');
}
Element.setContentZoom = function(element, percent) {
element = $(element);
Element.setStyle(element, {fontSize: (percent/100) + 'em'});
if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
}
Element.getOpacity = function(element){
var opacity;
if (opacity = Element.getStyle(element, 'opacity'))
return parseFloat(opacity);
if (opacity = (Element.getStyle(element, 'filter') || '').match(/alpha\(opacity=(.*)\)/))
if(opacity[1]) return parseFloat(opacity[1]) / 100;
return 1.0;
}
Element.setOpacity = function(element, value){
element= $(element);
if (value == 1){
Element.setStyle(element, { opacity:
(/Gecko/.test(navigator.userAgent) && !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ?
0.999999 : null });
if(/MSIE/.test(navigator.userAgent))
Element.setStyle(element, {filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'')});
} else {
if(value < 0.00001) value = 0;
Element.setStyle(element, {opacity: value});
if(/MSIE/.test(navigator.userAgent))
Element.setStyle(element,
{ filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'') +
'alpha(opacity='+value*100+')' });
}
}
Element.getInlineOpacity = function(element){
return $(element).style.opacity || '';
}
Element.childrenWithClassName = function(element, className, findFirst) {
var classNameRegExp = new RegExp("(^|\\s)" + className + "(\\s|$)");
var results = $A($(element).getElementsByTagName('*'))[findFirst ? 'detect' : 'select']( function(c) {
return (c.className && c.className.match(classNameRegExp));
});
if(!results) results = [];
return results;
}
Element.forceRerendering = function(element) {
try {
element = $(element);
var n = document.createTextNode(' ');
element.appendChild(n);
element.removeChild(n);
} catch(e) { }
};
/*--------------------------------------------------------------------------*/
Array.prototype.call = function() {
var args = arguments;
this.each(function(f){ f.apply(this, args) });
}
/*--------------------------------------------------------------------------*/
var Effect = {
tagifyText: function(element) {
var tagifyStyle = 'position:relative';
if(/MSIE/.test(navigator.userAgent)) tagifyStyle += ';zoom:1';
element = $(element);
$A(element.childNodes).each( function(child) {
if(child.nodeType==3) {
child.nodeValue.toArray().each( function(character) {
element.insertBefore(
Builder.node('span',{style: tagifyStyle},
character == ' ' ? String.fromCharCode(160) : character),
child);
});
Element.remove(child);
}
});
},
multiple: function(element, effect) {
var elements;
if(((typeof element == 'object') ||
(typeof element == 'function')) &&
(element.length))
elements = element;
else
elements = $(element).childNodes;
var options = Object.extend({
speed: 0.1,
delay: 0.0
}, arguments[2] || {});
var masterDelay = options.delay;
$A(elements).each( function(element, index) {
new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
});
},
PAIRS: {
'slide': ['SlideDown','SlideUp'],
'blind': ['BlindDown','BlindUp'],
'appear': ['Appear','Fade']
},
toggle: function(element, effect) {
element = $(element);
effect = (effect || 'appear').toLowerCase();
var options = Object.extend({
queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
}, arguments[2] || {});
Effect[element.visible() ?
Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
}
};
var Effect2 = Effect; // deprecated
/* ------------- transitions ------------- */
Effect.Transitions = {}
Effect.Transitions.linear = function(pos) {
return pos;
}
Effect.Transitions.sinoidal = function(pos) {
return (-Math.cos(pos*Math.PI)/2) + 0.5;
}
Effect.Transitions.reverse = function(pos) {
return 1-pos;
}
Effect.Transitions.flicker = function(pos) {
return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
}
Effect.Transitions.wobble = function(pos) {
return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
}
Effect.Transitions.pulse = function(pos) {
return (Math.floor(pos*10) % 2 == 0 ?
(pos*10-Math.floor(pos*10)) : 1-(pos*10-Math.floor(pos*10)));
}
Effect.Transitions.none = function(pos) {
return 0;
}
Effect.Transitions.full = function(pos) {
return 1;
}
/* ------------- core effects ------------- */
Effect.ScopedQueue = Class.create();
Object.extend(Object.extend(Effect.ScopedQueue.prototype, Enumerable), {
initialize: function() {
this.effects = [];
this.interval = null;
},
_each: function(iterator) {
this.effects._each(iterator);
},
add: function(effect) {
var timestamp = new Date().getTime();
var position = (typeof effect.options.queue == 'string') ?
effect.options.queue : effect.options.queue.position;
switch(position) {
case 'front':
// move unstarted effects after this effect
this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
e.startOn += effect.finishOn;
e.finishOn += effect.finishOn;
});
break;
case 'end':
// start effect after last queued effect has finished
timestamp = this.effects.pluck('finishOn').max() || timestamp;
break;
}
effect.startOn += timestamp;
effect.finishOn += timestamp;
if(!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
this.effects.push(effect);
if(!this.interval)
this.interval = setInterval(this.loop.bind(this), 40);
},
remove: function(effect) {
this.effects = this.effects.reject(function(e) { return e==effect });
if(this.effects.length == 0) {
clearInterval(this.interval);
this.interval = null;
}
},
loop: function() {
var timePos = new Date().getTime();
this.effects.invoke('loop', timePos);
}
});
Effect.Queues = {
instances: $H(),
get: function(queueName) {
if(typeof queueName != 'string') return queueName;
if(!this.instances[queueName])
this.instances[queueName] = new Effect.ScopedQueue();
return this.instances[queueName];
}
}
Effect.Queue = Effect.Queues.get('global');
Effect.DefaultOptions = {
transition: Effect.Transitions.sinoidal,
duration: 1.0, // seconds
fps: 25.0, // max. 25fps due to Effect.Queue implementation
sync: false, // true for combining
from: 0.0,
to: 1.0,
delay: 0.0,
queue: 'parallel'
}
Effect.Base = function() {};
Effect.Base.prototype = {
position: null,
start: function(options) {
this.options = Object.extend(Object.extend({},Effect.DefaultOptions), options || {});
this.currentFrame = 0;
this.state = 'idle';
this.startOn = this.options.delay*1000;
this.finishOn = this.startOn + (this.options.duration*1000);
this.event('beforeStart');
if(!this.options.sync)
Effect.Queues.get(typeof this.options.queue == 'string' ?
'global' : this.options.queue.scope).add(this);
},
loop: function(timePos) {
if(timePos >= this.startOn) {
if(timePos >= this.finishOn) {
this.render(1.0);
this.cancel();
this.event('beforeFinish');
if(this.finish) this.finish();
this.event('afterFinish');
return;
}
var pos = (timePos - this.startOn) / (this.finishOn - this.startOn);
var frame = Math.round(pos * this.options.fps * this.options.duration);
if(frame > this.currentFrame) {
this.render(pos);
this.currentFrame = frame;
}
}
},
render: function(pos) {
if(this.state == 'idle') {
this.state = 'running';
this.event('beforeSetup');
if(this.setup) this.setup();
this.event('afterSetup');
}
if(this.state == 'running') {
if(this.options.transition) pos = this.options.transition(pos);
pos *= (this.options.to-this.options.from);
pos += this.options.from;
this.position = pos;
this.event('beforeUpdate');
if(this.update) this.update(pos);
this.event('afterUpdate');
}
},
cancel: function() {
if(!this.options.sync)
Effect.Queues.get(typeof this.options.queue == 'string' ?
'global' : this.options.queue.scope).remove(this);
this.state = 'finished';
},
event: function(eventName) {
if(this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
if(this.options[eventName]) this.options[eventName](this);
},
inspect: function() {
return '#<Effect:' + $H(this).inspect() + ',options:' + $H(this.options).inspect() + '>';
}
}
Effect.Parallel = Class.create();
Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype), {
initialize: function(effects) {
this.effects = effects || [];
this.start(arguments[1]);
},
update: function(position) {
this.effects.invoke('render', position);
},
finish: function(position) {
this.effects.each( function(effect) {
effect.render(1.0);
effect.cancel();
effect.event('beforeFinish');
if(effect.finish) effect.finish(position);
effect.event('afterFinish');
});
}
});
Effect.Opacity = Class.create();
Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), {
initialize: function(element) {
this.element = $(element);
// make this work on IE on elements without 'layout'
if(/MSIE/.test(navigator.userAgent) && (!this.element.hasLayout))
this.element.setStyle({zoom: 1});
var options = Object.extend({
from: this.element.getOpacity() || 0.0,
to: 1.0
}, arguments[1] || {});
this.start(options);
},
update: function(position) {
this.element.setOpacity(position);
}
});
Effect.Move = Class.create();
Object.extend(Object.extend(Effect.Move.prototype, Effect.Base.prototype), {
initialize: function(element) {
this.element = $(element);
var options = Object.extend({
x: 0,
y: 0,
mode: 'relative'
}, arguments[1] || {});
this.start(options);
},
setup: function() {
// Bug in Opera: Opera returns the "real" position of a static element or
// relative element that does not have top/left explicitly set.
// ==> Always set top and left for position relative elements in your stylesheets
// (to 0 if you do not need them)
this.element.makePositioned();
this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
this.originalTop = parseFloat(this.element.getStyle('top') || '0');
if(this.options.mode == 'absolute') {
// absolute movement, so we need to calc deltaX and deltaY
this.options.x = this.options.x - this.originalLeft;
this.options.y = this.options.y - this.originalTop;
}
},
update: function(position) {
this.element.setStyle({
left: this.options.x * position + this.originalLeft + 'px',
top: this.options.y * position + this.originalTop + 'px'
});
}
});
// for backwards compatibility
Effect.MoveBy = function(element, toTop, toLeft) {
return new Effect.Move(element,
Object.extend({ x: toLeft, y: toTop }, arguments[3] || {}));
};
Effect.Scale = Class.create();
Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
initialize: function(element, percent) {
this.element = $(element)
var options = Object.extend({
scaleX: true,
scaleY: true,
scaleContent: true,
scaleFromCenter: false,
scaleMode: 'box', // 'box' or 'contents' or {} with provided values
scaleFrom: 100.0,
scaleTo: percent
}, arguments[2] || {});
this.start(options);
},
setup: function() {
this.restoreAfterFinish = this.options.restoreAfterFinish || false;
this.elementPositioning = this.element.getStyle('position');
this.originalStyle = {};
['top','left','width','height','fontSize'].each( function(k) {
this.originalStyle[k] = this.element.style[k];
}.bind(this));
this.originalTop = this.element.offsetTop;
this.originalLeft = this.element.offsetLeft;
var fontSize = this.element.getStyle('font-size') || '100%';
['em','px','%'].each( function(fontSizeType) {
if(fontSize.indexOf(fontSizeType)>0) {
this.fontSize = parseFloat(fontSize);
this.fontSizeType = fontSizeType;
}
}.bind(this));
this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
this.dims = null;
if(this.options.scaleMode=='box')
this.dims = [this.element.offsetHeight, this.element.offsetWidth];
if(/^content/.test(this.options.scaleMode))
this.dims = [this.element.scrollHeight, this.element.scrollWidth];
if(!this.dims)
this.dims = [this.options.scaleMode.originalHeight,
this.options.scaleMode.originalWidth];
},
update: function(position) {
var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
if(this.options.scaleContent && this.fontSize)
this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
},
finish: function(position) {
if (this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
},
setDimensions: function(height, width) {
var d = {};
if(this.options.scaleX) d.width = width + 'px';
if(this.options.scaleY) d.height = height + 'px';
if(this.options.scaleFromCenter) {
var topd = (height - this.dims[0])/2;
var leftd = (width - this.dims[1])/2;
if(this.elementPositioning == 'absolute') {
if(this.options.scaleY) d.top = this.originalTop-topd + 'px';
if(this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
} else {
if(this.options.scaleY) d.top = -topd + 'px';
if(this.options.scaleX) d.left = -leftd + 'px';
}
}
this.element.setStyle(d);
}
});
Effect.Highlight = Class.create();
Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype), {
initialize: function(element) {
this.element = $(element);
var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || {});
this.start(options);
},
setup: function() {
// Prevent executing on elements not in the layout flow
if(this.element.getStyle('display')=='none') { this.cancel(); return; }
// Disable background image during the effect
this.oldStyle = {
backgroundImage: this.element.getStyle('background-image') };
this.element.setStyle({backgroundImage: 'none'});
if(!this.options.endcolor)
this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
if(!this.options.restorecolor)
this.options.restorecolor = this.element.getStyle('background-color');
// init color calculations
this._base = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
},
update: function(position) {
this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart()); }.bind(this)) });
},
finish: function() {
this.element.setStyle(Object.extend(this.oldStyle, {
backgroundColor: this.options.restorecolor
}));
}
});
Effect.ScrollTo = Class.create();
Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype), {
initialize: function(element) {
this.element = $(element);
this.start(arguments[1] || {});
},
setup: function() {
Position.prepare();
var offsets = Position.cumulativeOffset(this.element);
if(this.options.offset) offsets[1] += this.options.offset;
var max = window.innerHeight ?
window.height - window.innerHeight :
document.body.scrollHeight -
(document.documentElement.clientHeight ?
document.documentElement.clientHeight : document.body.clientHeight);
this.scrollStart = Position.deltaY;
this.delta = (offsets[1] > max ? max : offsets[1]) - this.scrollStart;
},
update: function(position) {
Position.prepare();
window.scrollTo(Position.deltaX,
this.scrollStart + (position*this.delta));
}
});
/* ------------- combination effects ------------- */
Effect.Fade = function(element) {
element = $(element);
var oldOpacity = element.getInlineOpacity();
var options = Object.extend({
from: element.getOpacity() || 1.0,
to: 0.0,
afterFinishInternal: function(effect) {
if(effect.options.to!=0) return;
effect.element.hide();
effect.element.setStyle({opacity: oldOpacity});
}}, arguments[1] || {});
return new Effect.Opacity(element,options);
}
Effect.Appear = function(element) {
element = $(element);
var options = Object.extend({
from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
to: 1.0,
// force Safari to render floated elements properly
afterFinishInternal: function(effect) {
effect.element.forceRerendering();
},
beforeSetup: function(effect) {
effect.element.setOpacity(effect.options.from);
effect.element.show();
}}, arguments[1] || {});
return new Effect.Opacity(element,options);
}
Effect.Puff = function(element) {
element = $(element);
var oldStyle = { opacity: element.getInlineOpacity(), position: element.getStyle('position') };
return new Effect.Parallel(
[ new Effect.Scale(element, 200,
{ sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }),
new Effect.Opacity(element, { sync: true, to: 0.0 } ) ],
Object.extend({ duration: 1.0,
beforeSetupInternal: function(effect) {
effect.effects[0].element.setStyle({position: 'absolute'}); },
afterFinishInternal: function(effect) {
effect.effects[0].element.hide();
effect.effects[0].element.setStyle(oldStyle); }
}, arguments[1] || {})
);
}
Effect.BlindUp = function(element) {
element = $(element);
element.makeClipping();
return new Effect.Scale(element, 0,
Object.extend({ scaleContent: false,
scaleX: false,
restoreAfterFinish: true,
afterFinishInternal: function(effect) {
effect.element.hide();
effect.element.undoClipping();
}
}, arguments[1] || {})
);
}
Effect.BlindDown = function(element) {
element = $(element);
var elementDimensions = element.getDimensions();
return new Effect.Scale(element, 100,
Object.extend({ scaleContent: false,
scaleX: false,
scaleFrom: 0,
scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
restoreAfterFinish: true,
afterSetup: function(effect) {
effect.element.makeClipping();
effect.element.setStyle({height: '0px'});
effect.element.show();
},
afterFinishInternal: function(effect) {
effect.element.undoClipping();
}
}, arguments[1] || {})
);
}
Effect.SwitchOff = function(element) {
element = $(element);
var oldOpacity = element.getInlineOpacity();
return new Effect.Appear(element, {
duration: 0.4,
from: 0,
transition: Effect.Transitions.flicker,
afterFinishInternal: function(effect) {
new Effect.Scale(effect.element, 1, {
duration: 0.3, scaleFromCenter: true,
scaleX: false, scaleContent: false, restoreAfterFinish: true,
beforeSetup: function(effect) {
effect.element.makePositioned();
effect.element.makeClipping();
},
afterFinishInternal: function(effect) {
effect.element.hide();
effect.element.undoClipping();
effect.element.undoPositioned();
effect.element.setStyle({opacity: oldOpacity});
}
})
}
});
}
Effect.DropOut = function(element) {
element = $(element);
var oldStyle = {
top: element.getStyle('top'),
left: element.getStyle('left'),
opacity: element.getInlineOpacity() };
return new Effect.Parallel(
[ new Effect.Move(element, {x: 0, y: 100, sync: true }),
new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
Object.extend(
{ duration: 0.5,
beforeSetup: function(effect) {
effect.effects[0].element.makePositioned();
},
afterFinishInternal: function(effect) {
effect.effects[0].element.hide();
effect.effects[0].element.undoPositioned();
effect.effects[0].element.setStyle(oldStyle);
}
}, arguments[1] || {}));
}
Effect.Shake = function(element) {
element = $(element);
var oldStyle = {
top: element.getStyle('top'),
left: element.getStyle('left') };
return new Effect.Move(element,
{ x: 20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
new Effect.Move(effect.element,
{ x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
new Effect.Move(effect.element,
{ x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
new Effect.Move(effect.element,
{ x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
new Effect.Move(effect.element,
{ x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
new Effect.Move(effect.element,
{ x: -20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
effect.element.undoPositioned();
effect.element.setStyle(oldStyle);
}}) }}) }}) }}) }}) }});
}
Effect.SlideDown = function(element) {
element = $(element);
element.cleanWhitespace();
// SlideDown need to have the content of the element wrapped in a container element with fixed height!
var oldInnerBottom = $(element.firstChild).getStyle('bottom');
var elementDimensions = element.getDimensions();
return new Effect.Scale(element, 100, Object.extend({
scaleContent: false,
scaleX: false,
scaleFrom: 0,
scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
restoreAfterFinish: true,
afterSetup: function(effect) {
effect.element.makePositioned();
effect.element.firstChild.makePositioned();
if(window.opera) effect.element.setStyle({top: ''});
effect.element.makeClipping();
effect.element.setStyle({height: '0px'});
effect.element.show(); },
afterUpdateInternal: function(effect) {
effect.element.firstChild.setStyle({bottom:
(effect.dims[0] - effect.element.clientHeight) + 'px' });
},
afterFinishInternal: function(effect) {
effect.element.undoClipping();
// IE will crash if child is undoPositioned first
if(/MSIE/.test(navigator.userAgent)){
effect.element.undoPositioned();
effect.element.firstChild.undoPositioned();
}else{
effect.element.firstChild.undoPositioned();
effect.element.undoPositioned();
}
effect.element.firstChild.setStyle({bottom: oldInnerBottom}); }
}, arguments[1] || {})
);
}
Effect.SlideUp = function(element) {
element = $(element);
element.cleanWhitespace();
var oldInnerBottom = $(element.firstChild).getStyle('bottom');
return new Effect.Scale(element, 0,
Object.extend({ scaleContent: false,
scaleX: false,
scaleMode: 'box',
scaleFrom: 100,
restoreAfterFinish: true,
beforeStartInternal: function(effect) {
effect.element.makePositioned();
effect.element.firstChild.makePositioned();
if(window.opera) effect.element.setStyle({top: ''});
effect.element.makeClipping();
effect.element.show(); },
afterUpdateInternal: function(effect) {
effect.element.firstChild.setStyle({bottom:
(effect.dims[0] - effect.element.clientHeight) + 'px' }); },
afterFinishInternal: function(effect) {
effect.element.hide();
effect.element.undoClipping();
effect.element.firstChild.undoPositioned();
effect.element.undoPositioned();
effect.element.setStyle({bottom: oldInnerBottom}); }
}, arguments[1] || {})
);
}
// Bug in opera makes the TD containing this element expand for a instance after finish
Effect.Squish = function(element) {
return new Effect.Scale(element, window.opera ? 1 : 0,
{ restoreAfterFinish: true,
beforeSetup: function(effect) {
effect.element.makeClipping(effect.element); },
afterFinishInternal: function(effect) {
effect.element.hide(effect.element);
effect.element.undoClipping(effect.element); }
});
}
Effect.Grow = function(element) {
element = $(element);
var options = Object.extend({
direction: 'center',
moveTransition: Effect.Transitions.sinoidal,
scaleTransition: Effect.Transitions.sinoidal,
opacityTransition: Effect.Transitions.full
}, arguments[1] || {});
var oldStyle = {
top: element.style.top,
left: element.style.left,
height: element.style.height,
width: element.style.width,
opacity: element.getInlineOpacity() };
var dims = element.getDimensions();
var initialMoveX, initialMoveY;
var moveX, moveY;
switch (options.direction) {
case 'top-left':
initialMoveX = initialMoveY = moveX = moveY = 0;
break;
case 'top-right':
initialMoveX = dims.width;
initialMoveY = moveY = 0;
moveX = -dims.width;
break;
case 'bottom-left':
initialMoveX = moveX = 0;
initialMoveY = dims.height;
moveY = -dims.height;
break;
case 'bottom-right':
initialMoveX = dims.width;
initialMoveY = dims.height;
moveX = -dims.width;
moveY = -dims.height;
break;
case 'center':
initialMoveX = dims.width / 2;
initialMoveY = dims.height / 2;
moveX = -dims.width / 2;
moveY = -dims.height / 2;
break;
}
return new Effect.Move(element, {
x: initialMoveX,
y: initialMoveY,
duration: 0.01,
beforeSetup: function(effect) {
effect.element.hide();
effect.element.makeClipping();
effect.element.makePositioned();
},
afterFinishInternal: function(effect) {
new Effect.Parallel(
[ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
new Effect.Scale(effect.element, 100, {
scaleMode: { originalHeight: dims.height, originalWidth: dims.width },
sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
], Object.extend({
beforeSetup: function(effect) {
effect.effects[0].element.setStyle({height: '0px'});
effect.effects[0].element.show();
},
afterFinishInternal: function(effect) {
effect.effects[0].element.undoClipping();
effect.effects[0].element.undoPositioned();
effect.effects[0].element.setStyle(oldStyle);
}
}, options)
)
}
});
}
Effect.Shrink = function(element) {
element = $(element);
var options = Object.extend({
direction: 'center',
moveTransition: Effect.Transitions.sinoidal,
scaleTransition: Effect.Transitions.sinoidal,
opacityTransition: Effect.Transitions.none
}, arguments[1] || {});
var oldStyle = {
top: element.style.top,
left: element.style.left,
height: element.style.height,
width: element.style.width,
opacity: element.getInlineOpacity() };
var dims = element.getDimensions();
var moveX, moveY;
switch (options.direction) {
case 'top-left':
moveX = moveY = 0;
break;
case 'top-right':
moveX = dims.width;
moveY = 0;
break;
case 'bottom-left':
moveX = 0;
moveY = dims.height;
break;
case 'bottom-right':
moveX = dims.width;
moveY = dims.height;
break;
case 'center':
moveX = dims.width / 2;
moveY = dims.height / 2;
break;
}
return new Effect.Parallel(
[ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
], Object.extend({
beforeStartInternal: function(effect) {
effect.effects[0].element.makePositioned();
effect.effects[0].element.makeClipping(); },
afterFinishInternal: function(effect) {
effect.effects[0].element.hide();
effect.effects[0].element.undoClipping();
effect.effects[0].element.undoPositioned();
effect.effects[0].element.setStyle(oldStyle); }
}, options)
);
}
Effect.Pulsate = function(element) {
element = $(element);
var options = arguments[1] || {};
var oldOpacity = element.getInlineOpacity();
var transition = options.transition || Effect.Transitions.sinoidal;
var reverser = function(pos){ return transition(1-Effect.Transitions.pulse(pos)) };
reverser.bind(transition);
return new Effect.Opacity(element,
Object.extend(Object.extend({ duration: 3.0, from: 0,
afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
}, options), {transition: reverser}));
}
Effect.Fold = function(element) {
element = $(element);
var oldStyle = {
top: element.style.top,
left: element.style.left,
width: element.style.width,
height: element.style.height };
Element.makeClipping(element);
return new Effect.Scale(element, 5, Object.extend({
scaleContent: false,
scaleX: false,
afterFinishInternal: function(effect) {
new Effect.Scale(element, 1, {
scaleContent: false,
scaleY: false,
afterFinishInternal: function(effect) {
effect.element.hide();
effect.element.undoClipping();
effect.element.setStyle(oldStyle);
} });
}}, arguments[1] || {}));
};
['setOpacity','getOpacity','getInlineOpacity','forceRerendering','setContentZoom',
'collectTextNodes','collectTextNodesIgnoreClass','childrenWithClassName'].each(
function(f) { Element.Methods[f] = Element[f]; }
);
Element.Methods.visualEffect = function(element, effect, options) {
s = effect.gsub(/_/, '-').camelize();
effect_class = s.charAt(0).toUpperCase() + s.substring(1);
new Effect[effect_class](element, options);
return $(element);
};
Element.addMethods();

4
vendor/plugins/asset_packager/test/assets/javascripts/foo.js vendored
View file

@ -1,4 +0,0 @@
foo foo foo
foo foo foo
foo foo foo

2006
vendor/plugins/asset_packager/test/assets/javascripts/prototype.js vendored
View file

File diff suppressed because it is too large Load diff

16
vendor/plugins/asset_packager/test/assets/stylesheets/bar.css vendored
View file

@ -1,16 +0,0 @@
#bar1 {
background: #fff;
color: #000;
text-align: center;
}
#bar2 {
background: #fff;
color: #000;
text-align: center;
}
#bar3 {
background: #fff;
color: #000;
text-align: center;
}

16
vendor/plugins/asset_packager/test/assets/stylesheets/foo.css vendored
View file

@ -1,16 +0,0 @@
#foo1 {
background: #fff;
color: #000;
text-align: center;
}
#foo2 {
background: #fff;
color: #000;
text-align: center;
}
#foo3 {
background: #fff;
color: #000;
text-align: center;
}

16
vendor/plugins/asset_packager/test/assets/stylesheets/header.css vendored
View file

@ -1,16 +0,0 @@
#header1 {
background: #fff;
color: #000;
text-align: center;
}
#header2 {
background: #fff;
color: #000;
text-align: center;
}
#header3 {
background: #fff;
color: #000;
text-align: center;
}

16
vendor/plugins/asset_packager/test/assets/stylesheets/screen.css vendored
View file

@ -1,16 +0,0 @@
#screen1 {
background: #fff;
color: #000;
text-align: center;
}
#screen2 {
background: #fff;
color: #000;
text-align: center;
}
#screen3 {
background: #fff;
color: #000;
text-align: center;
}

16
vendor/plugins/asset_packager/test/assets/stylesheets/subdir/bar.css vendored
View file

@ -1,16 +0,0 @@
#bar1 {
background: #fff;
color: #000;
text-align: center;
}
#bar2 {
background: #fff;
color: #000;
text-align: center;
}
#bar3 {
background: #fff;
color: #000;
text-align: center;
}

16
vendor/plugins/asset_packager/test/assets/stylesheets/subdir/foo.css vendored
View file

@ -1,16 +0,0 @@
#foo1 {
background: #fff;
color: #000;
text-align: center;
}
#foo2 {
background: #fff;
color: #000;
text-align: center;
}
#foo3 {
background: #fff;
color: #000;
text-align: center;
}

20
vendor/plugins/bundle-fu/MIT-LICENSE vendored Normal file
View file

@ -0,0 +1,20 @@
Copyright (c) 2007 Timothy Harper
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.

35
vendor/plugins/bundle-fu/README.textile vendored Normal file
View file

@ -0,0 +1,35 @@
h1. Bundle fu
-------------
Each css / js you load causes your site to load slower! You can speed things up
exponentially by simply combining all your css/js files into one file each.
Bundle_fu makes it easy to do. It's as easy as 1, 2!
h2. USAGE / INSTALLATION
------------------------
h3. Step 1
Install this plugin
script/plugin install git://github.com/timcharper/bundle-fu.git
h3. Step 2
Put the following around your stylesheets/javascripts (note it works with any method of including assets!):
<pre><code>
<% bundle do %>
...
<%= javascript_include_tag "prototype" %>
<%= stylesheet_link_tag "basic.css" %>
<%= calendar_date_select_includes params[:style] %>
<script src="javascripts/application.js" type="text/javascript"></script>
...
<% end %>
</code></pre>
That's it!
"More info":http://code.google.com/p/bundle-fu/

4
vendor/plugins/bundle-fu/environment.rb vendored Normal file
View file

@ -0,0 +1,4 @@
# load all files
for file in ["/lib/bundle_fu.rb", "/lib/bundle_fu/js_minimizer.rb", "/lib/bundle_fu/css_url_rewriter.rb", "/lib/bundle_fu/file_list.rb"]
require File.expand_path(File.join(File.dirname(__FILE__), file))
end

6
vendor/plugins/bundle-fu/init.rb vendored Normal file
View file

@ -0,0 +1,6 @@
# EZ Bundle
for file in ["/lib/bundle_fu.rb", "/lib/js_minimizer.rb", "/lib/bundle_fu/file_list.rb"]
end
require File.expand_path(File.join(File.dirname(__FILE__), "environment.rb"))
ActionView::Base.send(:include, BundleFu::InstanceMethods)

146
vendor/plugins/bundle-fu/lib/bundle_fu.rb vendored Normal file
View file

@ -0,0 +1,146 @@
class BundleFu
class << self
attr_accessor :content_store
def init
@content_store = {}
end
def bundle_files(filenames=[])
output = ""
filenames.each{ |filename|
output << "/* --------- #{filename} --------- */ "
output << "\n"
begin
content = (File.read(File.join(RAILS_ROOT, "public", filename)))
rescue
output << "/* FILE READ ERROR! */"
next
end
output << (yield(filename, content)||"")
}
output
end
def bundle_js_files(filenames=[], options={})
output =
bundle_files(filenames) { |filename, content|
if options[:compress]
if Object.const_defined?("Packr")
content
else
JSMinimizer.minimize_content(content)
end
else
content
end
}
if Object.const_defined?("Packr")
# use Packr plugin (http://blog.jcoglan.com/packr/)
Packr.new.pack(output, options[:packr_options] || {:shrink_vars => false, :base62 => false})
else
output
end
end
def bundle_css_files(filenames=[], options = {})
bundle_files(filenames) { |filename, content|
BundleFu::CSSUrlRewriter.rewrite_urls(filename, content)
}
end
end
self.init
module InstanceMethods
# valid options:
# :name - The name of the css and js files you wish to output
# returns true if a regen occured. False if not.
def bundle(options={}, &block)
# allow bypassing via the querystring
session[:bundle_fu] = (params[:bundle_fu]=="true") if params.has_key?(:bundle_fu)
options = {
:css_path => ($bundle_css_path || "/stylesheets/cache"),
:js_path => ($bundle_js_path || "/javascripts/cache"),
:name => ($bundle_default_name || "bundle"),
:compress => true,
:bundle_fu => ( session[:bundle_fu].nil? ? ($bundle_fu.nil? ? true : $bundle_fu) : session[:bundle_fu] )
}.merge(options)
# allow them to bypass via parameter
options[:bundle_fu] = false if options[:bypass]
paths = { :css => options[:css_path], :js => options[:js_path] }
content = capture(&block)
content_changed = false
new_files = nil
abs_filelist_paths = [:css, :js].inject({}) { | hash, filetype | hash[filetype] = File.join(RAILS_ROOT, "public", paths[filetype], "#{options[:name]}.#{filetype}.filelist"); hash }
# only rescan file list if content_changed, or if a filelist cache file is missing
unless content == BundleFu.content_store[options[:name]] && File.exists?(abs_filelist_paths[:css]) && File.exists?(abs_filelist_paths[:js])
BundleFu.content_store[options[:name]] = content
new_files = {:js => [], :css => []}
content.scan(/(href|src) *= *["']([^"^'^\?]+)/i).each{ |property, value|
case property
when "src"
new_files[:js] << value
when "href"
new_files[:css] << value
end
}
end
[:css, :js].each { |filetype|
output_filename = File.join(paths[filetype], "#{options[:name]}.#{filetype}")
abs_path = File.join(RAILS_ROOT, "public", output_filename)
abs_filelist_path = abs_filelist_paths[filetype]
filelist = FileList.open( abs_filelist_path )
# check against newly parsed filelist. If we didn't parse the filelist from the output, then check against the updated mtimes.
new_filelist = new_files ? BundleFu::FileList.new(new_files[filetype]) : filelist.clone.update_mtimes
unless new_filelist == filelist
FileUtils.mkdir_p(File.join(RAILS_ROOT, "public", paths[filetype]))
# regenerate everything
if new_filelist.filenames.empty?
# delete the javascript/css bundle file if it's empty, but keep the filelist cache
FileUtils.rm_f(abs_path)
else
# call bundle_css_files or bundle_js_files to bundle all files listed. output it's contents to a file
output = BundleFu.send("bundle_#{filetype}_files", new_filelist.filenames, options)
File.open( abs_path, "w") {|f| f.puts output } if output
end
new_filelist.save_as(abs_filelist_path)
end
if File.exists?(abs_path) && options[:bundle_fu]
tag = filetype==:css ? stylesheet_link_tag(output_filename) : javascript_include_tag(output_filename)
if Rails::version < "2.2.0"
concat( tag , block.binding)
else
#concat doesn't need block.binding in Rails >= 2.2.0
concat( tag )
end
end
}
unless options[:bundle_fu]
if Rails::version < "2.2.0"
concat( content, block.binding )
else
#concat doesn't need block.binding in Rails >= 2.2.0
concat( content )
end
end
end
end
end

42
vendor/plugins/bundle-fu/lib/bundle_fu/css_url_rewriter.rb vendored Normal file
View file

@ -0,0 +1,42 @@
class BundleFu::CSSUrlRewriter
class << self
# rewrites a relative path to an absolute path, removing excess "../" and "./"
# rewrite_relative_path("stylesheets/default/global.css", "../image.gif") => "/stylesheets/image.gif"
def rewrite_relative_path(source_filename, relative_url)
relative_url = relative_url.to_s.strip.gsub(/["']/, "")
return relative_url if relative_url.first == "/" || relative_url.include?("://")
elements = File.join("/", File.dirname(source_filename)).gsub(/\/+/, '/').split("/")
elements += relative_url.gsub(/\/+/, '/').split("/")
index = 0
while(elements[index])
if (elements[index]==".")
elements.delete_at(index)
elsif (elements[index]=="..")
next if index==0
index-=1
2.times { elements.delete_at(index)}
else
index+=1
end
end
elements * "/"
end
# rewrite the URL reference paths
# url(../../../images/active_scaffold/default/add.gif);
# url(/stylesheets/active_scaffold/default/../../../images/active_scaffold/default/add.gif);
# url(/stylesheets/active_scaffold/../../images/active_scaffold/default/add.gif);
# url(/stylesheets/../images/active_scaffold/default/add.gif);
# url('/images/active_scaffold/default/add.gif');
def rewrite_urls(filename, content)
content.gsub!(/url *\(([^\)]+)\)/) { "url(#{rewrite_relative_path(filename, $1)})" }
content
end
end
end

64
vendor/plugins/bundle-fu/lib/bundle_fu/file_list.rb vendored Normal file
View file

@ -0,0 +1,64 @@
require 'fileutils.rb'
class BundleFu::FileList
attr_accessor :filelist
def initialize(filenames=[])
self.filelist = []
self.add_files(filenames)
end
def initialize_copy(from)
self.filelist = from.filelist.collect{|entry| entry.clone}
end
def filenames
self.filelist.collect{ |entry| entry[0] }
end
def update_mtimes
old_filenames = self.filenames
self.filelist = []
# readding the files will effectively update the mtimes
self.add_files(old_filenames)
self
end
def self.open(filename)
return nil unless File.exists?(filename)
b = new
File.open(filename, "rb") {|f|
b.filelist = Marshal.load(f) # rescue [])
}
b
rescue
nil
end
# compares to see if one file list is exactly the same as another
def ==(compare)
return false if compare.nil?
throw "cant compare with #{compare.class}" unless self.class===compare
self.filelist == compare.filelist
end
def add_files(filenames=[])
filenames.each{|filename|
self.filelist << [ extract_filename_from_url(filename), (File.mtime(abs_location(filename)).to_i rescue 0) ]
}
end
def extract_filename_from_url(url)
url.gsub(/^https?:\/\/[^\/]+/i, '')
end
def save_as(filename)
File.open(filename, "wb") {|f| f.puts Marshal.dump(self.filelist)}
end
protected
def abs_location(filename)
File.join(RAILS_ROOT, "public", filename)
end
end

217
vendor/plugins/bundle-fu/lib/bundle_fu/js_minimizer.rb vendored Normal file
View file

@ -0,0 +1,217 @@
#!/usr/bin/ruby
# jsmin.rb 2007-07-20
# Author: Uladzislau Latynski
# This work is a translation from C to Ruby of jsmin.c published by
# Douglas Crockford. Permission is hereby granted to use the Ruby
# version under the same conditions as the jsmin.c on which it is
# based.
#
# /* jsmin.c
# 2003-04-21
#
# Copyright (c) 2002 Douglas Crockford (www.crockford.com)
#
# 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 shall be used for Good, not Evil.
#
# 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.
require 'stringio'
class BundleFu::JSMinimizer
attr_accessor :input
attr_accessor :output
EOF = -1
@theA = ""
@theB = ""
# isAlphanum -- return true if the character is a letter, digit, underscore,
# dollar sign, or non-ASCII character
def isAlphanum(c)
return false if !c || c == EOF
return ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') ||
(c >= 'A' && c <= 'Z') || c == '_' || c == '$' ||
c == '\\' || c[0] > 126)
end
# get -- return the next character from input. Watch out for lookahead. If
# the character is a control character, translate it to a space or linefeed.
def get()
c = @input.getc
return EOF if(!c)
c = c.chr
return c if (c >= " " || c == "\n" || c.unpack("c") == EOF)
return "\n" if (c == "\r")
return " "
end
# Get the next character without getting it.
def peek()
lookaheadChar = @input.getc
@input.ungetc(lookaheadChar)
return lookaheadChar.chr
end
# mynext -- get the next character, excluding comments.
# peek() is used to see if a '/' is followed by a '/' or '*'.
def mynext()
c = get
if (c == "/")
if(peek == "/")
while(true)
c = get
if (c <= "\n")
return c
end
end
end
if(peek == "*")
get
while(true)
case get
when "*"
if (peek == "/")
get
return " "
end
when EOF
raise "Unterminated comment"
end
end
end
end
return c
end
# action -- do something! What you do is determined by the argument: 1
# Output A. Copy B to A. Get the next B. 2 Copy B to A. Get the next B.
# (Delete A). 3 Get the next B. (Delete B). action treats a string as a
# single character. Wow! action recognizes a regular expression if it is
# preceded by ( or , or =.
def action(a)
if(a==1)
@output.write @theA
end
if(a==1 || a==2)
@theA = @theB
if (@theA == "\'" || @theA == "\"")
while (true)
@output.write @theA
@theA = get
break if (@theA == @theB)
raise "Unterminated string literal" if (@theA <= "\n")
if (@theA == "\\")
@output.write @theA
@theA = get
end
end
end
end
if(a==1 || a==2 || a==3)
@theB = mynext
if (@theB == "/" && (@theA == "(" || @theA == "," || @theA == "=" ||
@theA == ":" || @theA == "[" || @theA == "!" ||
@theA == "&" || @theA == "|" || @theA == "?" ||
@theA == "{" || @theA == "}" || @theA == ";" ||
@theA == "\n"))
@output.write @theA
@output.write @theB
while (true)
@theA = get
if (@theA == "/")
break
elsif (@theA == "\\")
@output.write @theA
@theA = get
elsif (@theA <= "\n")
raise "Unterminated RegExp Literal"
end
@output.write @theA
end
@theB = mynext
end
end
end
# jsmin -- Copy the input to the output, deleting the characters which are
# insignificant to JavaScript. Comments will be removed. Tabs will be
# replaced with spaces. Carriage returns will be replaced with linefeeds.
# Most spaces and linefeeds will be removed.
def jsmin
@theA = "\n"
action(3)
while (@theA != EOF)
case @theA
when " "
if (isAlphanum(@theB))
action(1)
else
action(2)
end
when "\n"
case (@theB)
when "{","[","(","+","-"
action(1)
when " "
action(3)
else
if (isAlphanum(@theB))
action(1)
else
action(2)
end
end
else
case (@theB)
when " "
if (isAlphanum(@theA))
action(1)
else
action(3)
end
when "\n"
case (@theA)
when "}","]",")","+","-","\"","\\", "'", '"'
action(1)
else
if (isAlphanum(@theA))
action(1)
else
action(3)
end
end
else
action(1)
end
end
end
end
def self.minimize_content(content)
js_minimizer = new
js_minimizer.input = StringIO.new(content)
js_minimizer.output = StringIO.new
js_minimizer.jsmin
js_minimizer.output.string
end
end

12
vendor/plugins/bundle-fu/test/fixtures/public/javascripts/js_1.js vendored Normal file
View file

@ -0,0 +1,12 @@
function js_1() { alert('hi')};
// this is a function
function func() {
alert('hi')
return true
}
function func() {
alert('hi')
return true
}

1
vendor/plugins/bundle-fu/test/fixtures/public/javascripts/js_2.js vendored Normal file
View file

@ -0,0 +1 @@
function js_2() { alert('hi');};

1
vendor/plugins/bundle-fu/test/fixtures/public/javascripts/js_3.js vendored Normal file
View file

@ -0,0 +1 @@
function js_3() { alert('hi')};

1
vendor/plugins/bundle-fu/test/fixtures/public/stylesheets/css_1.css vendored Normal file
View file

@ -0,0 +1 @@
css_1 { }

1
vendor/plugins/bundle-fu/test/fixtures/public/stylesheets/css_2.css vendored Normal file
View file

@ -0,0 +1 @@
css_2

7
vendor/plugins/bundle-fu/test/fixtures/public/stylesheets/css_3.css vendored Normal file
View file

@ -0,0 +1,7 @@
.relative_image_bg {
background-image: url(../images/background.gif )
}
.relative_image_bg_2 {
background-image: url( ../images/groovy/background_2.gif )
}

228
vendor/plugins/bundle-fu/test/functional/bundle_fu_test.rb vendored Normal file
View file

@ -0,0 +1,228 @@
require File.join(File.dirname(__FILE__), '../test_helper.rb')
require "test/unit"
# require "library_file_name"
class BundleFuTest < Test::Unit::TestCase
def setup
@mock_view = MockView.new
BundleFu.init # resets BundleFu
end
def teardown
purge_cache
end
def test__bundle_js_files__should_include_js_content
@mock_view.bundle { @@content_include_all }
assert_public_files_match("/javascripts/cache/bundle.js", "function js_1()")
end
def test__bundle_js_files_with_asset_server_url
@mock_view.bundle { %(<script src="https://assets.server.com/javascripts/js_1.js?1000" type="text/javascript"></script>) }
assert_public_files_match("/javascripts/cache/bundle.js", "function js_1()")
end
def test__bundle_js_files__should_use_packr
Object.send :class_eval, <<EOF
class ::Object::Packr
def initialize
end
def pack(content, options={})
"PACKR!" + options.inspect
end
end
EOF
@mock_view.bundle() { @@content_include_all }
assert_public_files_match("/javascripts/cache/bundle.js", "PACKR")
purge_cache
@mock_view.bundle(:packr_options => {:packr_options_here => "hi_packr"}) { @@content_include_all }
assert_public_files_match("/javascripts/cache/bundle.js", "packr_options_here", "Should include packr_options")
Object.send :remove_const, "Packr"
end
def test__bundle_js_files__should_default_to_not_compressed_and_include_override_option
@mock_view.bundle() { @@content_include_all }
default_content = File.read(public_file("/javascripts/cache/bundle.js"))
purge_cache
@mock_view.bundle(:compress => false) { @@content_include_all }
uncompressed_content = File.read(public_file("/javascripts/cache/bundle.js"))
purge_cache
@mock_view.bundle(:compress => true) { @@content_include_all }
compressed_content = File.read(public_file("/javascripts/cache/bundle.js"))
purge_cache
assert default_content.length == compressed_content.length, "Should default to compressed"
assert uncompressed_content.length > compressed_content.length, "Didn't compress the content. (:compress => true) #{compressed_content.length}. (:compress => false) #{uncompressed_content.length}"
end
def test__content_remains_same__shouldnt_refresh_cache
@mock_view.bundle { @@content_include_some }
# check to see each bundle file exists and append some text to the bottom of each file
append_to_public_files(cache_files("bundle"), "BOGUS")
assert_public_files_match("/javascripts/cache/bundle.js", "BOGUS")
assert_public_files_match("/stylesheets/cache/bundle.css", "BOGUS")
@mock_view.bundle { @@content_include_some }
assert_public_files_match("/javascripts/cache/bundle.js", "BOGUS")
assert_public_files_match("/stylesheets/cache/bundle.css", "BOGUS")
end
def test__content_changes__should_refresh_cache
@mock_view.bundle { @@content_include_some }
# check to see each bundle file exists and append some text to the bottom of each file
append_to_public_files(cache_files("bundle"), "BOGUS")
assert_public_files_match(cache_files("bundle"), "BOGUS")
# now, pass in some new content. Make sure that the css/js files are regenerated
@mock_view.bundle { @@content_include_all }
assert_public_files_no_match(cache_files("bundle"), "BOGUS")
assert_public_files_no_match(cache_files("bundle"), "BOGUS")
end
def test__modified_time_differs_from_file__should_refresh_cache
@mock_view.bundle { @@content_include_some }
# we're gonna hack each of them and set all the modified times to 0
cache_files("bundle").each{|filename|
abs_filelist_path = public_file(filename + ".filelist")
b = BundleFu::FileList.open(abs_filelist_path)
b.filelist.each{|entry| entry[1] = entry[1] - 100 }
b.save_as(abs_filelist_path)
}
append_to_public_files(cache_files("bundle"), "BOGUS")
end
def test__content_remains_same_but_cache_files_dont_match_whats_in_content__shouldnt_refresh_cache
# it shouldnt parse the content unless if it differed from the last request. This scenario should never exist, and if it did it would be fixed when the server reboots.
@mock_view.bundle { @@content_include_some }
abs_filelist_path = public_file("/stylesheets/cache/bundle.css.filelist")
b = BundleFu::FileList.open(abs_filelist_path)
@mock_view.bundle { @@content_include_all }
b.save_as(abs_filelist_path)
append_to_public_files(cache_files("bundle"), "BOGUS")
@mock_view.bundle { @@content_include_all }
assert_public_files_match(cache_files("bundle"), "BOGUS")
end
def test__content_differs_slightly_but_cache_files_match__shouldnt_refresh_cache
@mock_view.bundle { @@content_include_all }
append_to_public_files(cache_files("bundle"), "BOGUS")
@mock_view.bundle { @@content_include_all + " " }
assert_public_files_match(cache_files("bundle"), "BOGUS")
end
def test__bundle__js_only__should_output_js_include_statement
@mock_view.bundle { @@content_include_some.split("\n").first }
lines = @mock_view.output.split("\n")
assert_equal(1, lines.length)
assert_match(/javascripts/, lines.first)
end
def test__bundle__css_only__should_output_css_include_statement
@mock_view.bundle { @@content_include_some.split("\n")[2] }
lines = @mock_view.output.split("\n")
assert_equal(1, lines.length)
assert_match(/stylesheets/, lines.first)
end
def test__nonexisting_file__should_use_blank_file_created_at_0_mtime
# dbg
@mock_view.bundle { %q{<script src="/javascripts/non_existing_file.js?1000" type="text/javascript"></script>} }
assert_public_files_match(cache_files("bundle").grep(/javascripts/), "FILE READ ERROR")
filelist = BundleFu::FileList.open(public_file("/javascripts/cache/bundle.js.filelist"))
assert_equal(0, filelist.filelist[0][1], "mtime for first file should be 0")
end
def test__missing_cache_filelist__should_regenerate
@mock_view.bundle { @@content_include_some }
append_to_public_files(cache_files("bundle"), "BOGUS")
# now delete the cache files
Dir[ public_file("**/*.filelist")].each{|filename| FileUtils.rm_f filename }
@mock_view.bundle { @@content_include_some }
assert_public_files_no_match(cache_files("bundle"), "BOGUS", "Should have regenerated the file, but it didn't")
end
def test__bypass__should_generate_files_but_render_normal_output
@mock_view.bundle(:bypass => true) { @@content_include_some }
assert_public_file_exists("/stylesheets/cache/bundle.css")
assert_public_file_exists("/stylesheets/cache/bundle.css.filelist")
assert_equal(@@content_include_some, @mock_view.output)
end
def test__bypass_param_set__should_honor_and_store_in_session
@mock_view.params[:bundle_fu] = "false"
@mock_view.bundle { @@content_include_some }
assert_equal(@@content_include_some, @mock_view.output)
@mock_view.params.delete(:bundle_bypass)
@mock_view.bundle { @@content_include_some }
assert_equal(@@content_include_some*2, @mock_view.output)
end
private
def purge_cache
# remove all fixtures named "bundle*"
Dir[ public_file("**/cache") ].each{|filename| FileUtils.rm_rf filename }
end
def assert_public_file_exists(filename, message=nil)
assert_file_exists(public_file(filename), message)
end
def assert_file_exists(filename, message=nil)
assert(File.exists?(filename), message || "File #{filename} expected to exist, but didnt.")
end
def assert_public_files_match(filenames, needle, message=nil)
filenames.each{|filename|
assert_public_file_exists(filename)
assert_match(needle.to_regexp, File.read(public_file(filename)), message || "expected #{filename} to match #{needle}, but doesn't.")
}
end
def assert_public_files_no_match(filenames, needle, message=nil)
filenames.each{ |filename|
assert_public_file_exists(filename)
assert_no_match(needle.to_regexp, File.read(public_file(filename)), message || "expected #{filename} to not match #{needle}, but does.")
}
end
def cache_files(name)
["/javascripts/cache/#{name}.js", "/stylesheets/cache/#{name}.css"]
end
def append_to_public_files(filenames, content)
for filename in filenames
assert_public_file_exists(filename)
File.open(public_file(filename), "a") {|f|
f.puts(content)
}
end
end
end

55
vendor/plugins/bundle-fu/test/functional/css_bundle_test.rb vendored Normal file
View file

@ -0,0 +1,55 @@
require File.join(File.dirname(__FILE__), '../test_helper.rb')
class CSSBundleTest < Test::Unit::TestCase
def test__rewrite_relative_path__should_rewrite
assert_rewrites("/stylesheets/active_scaffold/default/stylesheet.css",
"../../../images/spinner.gif" => "/images/spinner.gif",
"../../../images/./../images/goober/../spinner.gif" => "/images/spinner.gif"
)
assert_rewrites("stylesheets/active_scaffold/default/./stylesheet.css",
"../../../images/spinner.gif" => "/images/spinner.gif")
assert_rewrites("stylesheets/main.css",
"image.gif" => "/stylesheets/image.gif")
assert_rewrites("/stylesheets////default/main.css",
"..//image.gif" => "/stylesheets/image.gif")
assert_rewrites("/stylesheets/default/main.css",
"/images/image.gif" => "/images/image.gif")
end
def test__rewrite_relative_path__should_strip_spaces_and_quotes
assert_rewrites("stylesheets/main.css",
"'image.gif'" => "/stylesheets/image.gif",
" image.gif " => "/stylesheets/image.gif"
)
end
def test__rewrite_relative_path__shouldnt_rewrite_if_absolute_url
assert_rewrites("stylesheets/main.css",
" 'http://www.url.com/images/image.gif' " => "http://www.url.com/images/image.gif",
"http://www.url.com/images/image.gif" => "http://www.url.com/images/image.gif",
"ftp://www.url.com/images/image.gif" => "ftp://www.url.com/images/image.gif"
)
end
def test__bundle_css_file__should_rewrite_relatiave_path
bundled_css = BundleFu.bundle_css_files(["/stylesheets/css_3.css"])
assert_match("background-image: url(/images/background.gif)", bundled_css)
assert_match("background-image: url(/images/groovy/background_2.gif)", bundled_css)
end
def test__bundle_css_files__no_images__should_return_content
bundled_css = BundleFu.bundle_css_files(["/stylesheets/css_1.css"])
assert_match("css_1 { }", bundled_css)
end
def assert_rewrites(source_filename, rewrite_map)
rewrite_map.each_pair{|source, dest|
assert_equal(dest, BundleFu::CSSUrlRewriter.rewrite_relative_path(source_filename, source))
}
end
end

46
vendor/plugins/bundle-fu/test/functional/file_list_test.rb vendored Normal file
View file

@ -0,0 +1,46 @@
require File.join(File.dirname(__FILE__), '../test_helper.rb')
require "test/unit"
# require "library_file_name"
class FileListTest < Test::Unit::TestCase
def setup
end
def test__new_files__should_get_mtimes
filename = "/javascripts/js_1.js"
filelist = BundleFu::FileList.new([filename])
assert_equal(File.mtime(File.join(RAILS_ROOT, "public", filename)).to_i,filelist.filelist[0][1])
end
def test__serialization
filelist_filename = File.join(RAILS_ROOT, "public", "temp")
filelist = BundleFu::FileList.new("/javascripts/js_1.js")
filelist.save_as(filelist_filename)
filelist2 = BundleFu::FileList.open(filelist_filename)
assert(filelist == filelist2, "expected to be same, but differed.\n#{filelist.to_yaml}\n\n#{filelist2.to_yaml}")
ensure
FileUtils.rm_f(filelist_filename)
end
def test__equality__same_file_and_mtime__should_equate
filename = "/javascripts/js_1.js"
assert BundleFu::FileList.new(filename) == BundleFu::FileList.new(filename)
end
def test__equality__dif_file_and_mtime__shouldnt_equate
filename1 = "/javascripts/js_1.js"
filename2 = "/javascripts/js_2.js"
assert BundleFu::FileList.new(filename1) != BundleFu::FileList.new(filename2)
end
def test__clone_item
b = BundleFu::FileList.new("/javascripts/js_1.js")
assert b == b.clone
end
end

14
vendor/plugins/bundle-fu/test/functional/js_bundle_test.rb vendored Normal file
View file

@ -0,0 +1,14 @@
require File.join(File.dirname(__FILE__), '../test_helper.rb')
class JSBundleTest < Test::Unit::TestCase
def test__bundle_js_files__bypass_bundle__should_bypass
BundleFu.bundle_js_files
end
def test__bundle_js_files__should_include_contents
bundled_js = BundleFu.bundle_js_files(["/javascripts/js_1.js"])
# puts bundled_js
# function js_1
assert_match("function js_1", bundled_js)
end
end

12
vendor/plugins/bundle-fu/test/functional/js_minimizer_test.rb vendored Normal file
View file

@ -0,0 +1,12 @@
require File.join(File.dirname(__FILE__), '../test_helper.rb')
class BundleFu::JSMinimizerTest < Test::Unit::TestCase
def test_minimize_content__should_be_less
test_content = File.read(public_file("javascripts/js_1.js"))
content_size = test_content.length
minimized_size = BundleFu::JSMinimizer.minimize_content(test_content).length
assert(minimized_size > 0)
assert(content_size > minimized_size)
end
end

31
vendor/plugins/bundle-fu/test/mock_view.rb vendored Normal file
View file

@ -0,0 +1,31 @@
class MockView
# set RAILS_ROOT to fixtures dir so we use those files
include BundleFu::InstanceMethods
::RAILS_ROOT = File.join(File.dirname(__FILE__), 'fixtures')
attr_accessor :output
attr_accessor :session
attr_accessor :params
def initialize
@output = ""
@session = {}
@params = {}
end
def capture(&block)
yield
end
def concat(output, *args)
@output << output
end
def stylesheet_link_tag(*args)
args.collect{|arg| "<link href=\"#{arg}?#{File.mtime(File.join(RAILS_ROOT, 'public', arg)).to_i}\" media=\"screen\" rel=\"Stylesheet\" type=\"text/css\" />" } * "\n"
end
def javascript_include_tag(*args)
args.collect{|arg| "<script src=\"#{arg}?#{File.mtime(File.join(RAILS_ROOT, 'public', arg)).to_i}\" type=\"text/javascript\"></script>" } * "\n"
end
end

3
vendor/plugins/bundle-fu/test/run_all.rb vendored Normal file
View file

@ -0,0 +1,3 @@
Dir[File.join(File.dirname(__FILE__), "functional/*.rb")].each{|filename|
require filename
}

38
vendor/plugins/bundle-fu/test/test_helper.rb vendored Normal file
View file

@ -0,0 +1,38 @@
require 'test/unit'
require "rubygems"
require 'active_support'
for file in ["../environment.rb", "mock_view.rb"]
require File.expand_path(File.join(File.dirname(__FILE__), file))
end
def dbg
require 'ruby-debug'
Debugger.start
debugger
end
class Object
def to_regexp
is_a?(Regexp) ? self : Regexp.new(Regexp.escape(self.to_s))
end
end
class Test::Unit::TestCase
@@content_include_some = <<-EOF
<script src="/javascripts/js_1.js?1000" type="text/javascript"></script>
<script src="/javascripts/js_2.js?1000" type="text/javascript"></script>
<link href="/stylesheets/css_1.css?1000" media="screen" rel="Stylesheet" type="text/css" />
<link href="/stylesheets/css_2.css?1000" media="screen" rel="Stylesheet" type="text/css" />
EOF
# the same content, slightly changed
@@content_include_all = @@content_include_some + <<-EOF
<script src="/javascripts/js_3.js?1000" type="text/javascript"></script>
<link href="/stylesheets/css_3.css?1000" media="screen" rel="Stylesheet" type="text/css" />
EOF
def public_file(filename)
File.join(::RAILS_ROOT, "public", filename)
end
end

2
vendor/plugins/extra_validations/lib/extra_validations.rb vendored
View file

@ -16,7 +16,7 @@ module ExtraValidations
# occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The
# method, proc or string should return or evaluate to a true or false value.
def validates_does_not_contain(*attr_names)
configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save, :string => nil }
configuration = { :message => I18n.translate('activerecord.errors.messages')[:invalid], :on => :save, :string => nil }
configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
raise(ArgumentError, "A string must be supplied as the :string option of the configuration hash") unless configuration[:string].is_a?(String)

13
vendor/plugins/flashobject_helper/lib/flashobject_view_helper.rb vendored
View file

@ -70,7 +70,18 @@ EOF
# flash_path "dir/movie.swf" # => /swf/dir/movie.swf
# flash_path "/dir/movie" # => /dir/movie.swf
def flash_path(source)
compute_public_path(source, 'swf', 'swf', false)
#BROKEN IN RAILS 2.2 -- code below hacked in pending a refresh of this plugin or change to another --luke@lukemelia.com
#compute_public_path(source, 'swf', 'swf', false)
dir = "/swf/"
if source !~ %r{^/}
source = "#{dir}#{source}"
end
relative_url_root = ActionController::Base.relative_url_root
if source !~ %r{^#{relative_url_root}/}
source = "#{relative_url_root}#{source}"
end
source
end
end

4
vendor/plugins/resource_feeder/lib/resource_feeder/atom.rb vendored
View file

@ -26,14 +26,14 @@ module ResourceFeeder
options[:feed][:title] ||= klass.name.pluralize
options[:feed][:id] ||= "tag:#{request.host_with_port}:#{klass.name.pluralize}"
options[:feed][:link] ||= polymorphic_url(new_record, :controller => options[:url_writer])
options[:feed][:link] ||= polymorphic_url(new_record, :controller => options[:url_writer].controller_name)
options[:item][:title] ||= [ :title, :subject, :headline, :name ]
options[:item][:description] ||= [ :description, :body, :content ]
options[:item][:pub_date] ||= [ :updated_at, :updated_on, :created_at, :created_on ]
options[:item][:author] ||= [ :author, :creator ]
resource_link = lambda { |r| polymorphic_url(r, :controller => options[:url_writer]) }
resource_link = lambda { |r| polymorphic_url(r, :controller => options[:url_writer].controller_name) }
xml.instruct!
xml.feed "xml:lang" => "en-US", "xmlns" => 'http://www.w3.org/2005/Atom' do

4
vendor/plugins/resource_feeder/lib/resource_feeder/rss.rb vendored
View file

@ -26,7 +26,7 @@ module ResourceFeeder
use_content_encoded = options[:item].has_key?(:content_encoded)
options[:feed][:title] ||= klass.name.pluralize
options[:feed][:link] ||= polymorphic_url(new_record, :controller => options[:url_writer])
options[:feed][:link] ||= polymorphic_url(new_record, :controller => options[:url_writer].controller_name)
options[:feed][:language] ||= "en-us"
options[:feed][:ttl] ||= "40"
@ -34,7 +34,7 @@ module ResourceFeeder
options[:item][:description] ||= [ :description, :body, :content ]
options[:item][:pub_date] ||= [ :updated_at, :updated_on, :created_at, :created_on ]
resource_link = lambda { |r| polymorphic_url(r, :controller => options[:url_writer]) }
resource_link = lambda { |r| polymorphic_url(r, :controller => options[:url_writer].controller_name) }
rss_root_attributes = { :version => 2.0 }
rss_root_attributes.merge!("xmlns:content" => "http://purl.org/rss/1.0/modules/content/") if use_content_encoded

3
vendor/plugins/rspec-rails/.gitignore vendored
View file

@ -2,3 +2,6 @@ tmtags
.DS_Store
.emacs-project
*~
pkg
doc
email.txt

26
vendor/plugins/rspec-rails/CHANGES vendored
View file

@ -1,26 +0,0 @@
== Version 1.1.5
* Add conditional so Rails 2.1.0 doesn't warn about cache_template_extensions (patch from James Herdman)
* Fixed stub_model examples to work with Rails 2.1.0 (the code was fine, just the spec needed patching)
== Version 1.1.4
Maintenance release.
* Moved mock_model and stub_model to their own module: Spec::Rails::Mocks
* Setting mock_model object id with stubs hash - patch from Adam Meehan
* Added as_new_record to stub_model e.g. stub_model(Foo).as_new_record
* Improved stub_model such that new_record? does "the right thing"
* Patch from Pat Maddox to get integrate_views to work in nested example groups.
* Patch from Pat Maddox to get controller_name to work in nested example groups.
* Patch from Corey Haines to add include_text matcher
* Added stub_model method which creates a real model instance with :id stubbed and data access prohibited.
* Applied patch from Pat Maddox to handle redirect_to w/ SSL. Closes #320.
* Added #helper and #assigns to helper specs.
* Applied patch from Bryan Helmkamp to tweak format of generated spec.opts to be more obvious. Closes #162.
* Tweaked list of exceptions (ignores) for autotest
* Applied patch from Rick Olson to get rspec_on_rails working with rails edge (>= 8862)
* Applied patch from Wincent Colaiuta to invert sense of "spec --diff". Closes #281.
* Allow any type of render in view specs. Closes #57.
* Applied patch from Ian White to get rspec working with edge rails (8804). Closes #271.
* Applied patch from Jon Strother to have spec_server reload fixtures. Closes #344.

82
vendor/plugins/rspec-rails/History.txt vendored Normal file
View file

@ -0,0 +1,82 @@
=== Maintenance
* 1 bug fix
* require 'rubygems' in script/spec
=== Version 1.1.8 / 2008-10-03
* 2 bug fixes
* correctly handle assigns that are false. Fixes #552.
* ensure that NotYetImplemented examples report as pending (fixed in rspec, not rspec-rails). Fixes #553.
=== Version 1.1.7 / 2008-10-02
* 1 bug fix
* depend on the correct version of rspec
=== Version 1.1.6 / 2008-10-02
* 1 bug fix
* fixed regression where values assigned to the assigns hash were not accessible from the example (#549)
=== Version 1.1.5 / 2008-09-28
IMPORTANT: use 'script/autospec' (or just 'autospec' if you have the rspec gem
installed) instead of 'autotest'. We changed the way autotest discovers rspec
so the autotest executable won't automatically load rspec anymore. This allows
rspec to live side by side other spec frameworks without always co-opting
autotest through autotest's discovery mechanism.
ALSO IMPORTANT: Rails v2.1.1 changed assert_select_rjs such that it doesn't
always fail when it should. Please see
http://rails.lighthouseapp.com/projects/8994/tickets/982.
* Generated route specs have shorter names, making it less painful to modify their implementation
* Add conditional so Rails 2.1.0 doesn't warn about cache_template_extensions (patch from James Herdman)
* Fixed stub_model examples to work with Rails 2.1.0 (the code was fine, just the examples needed patching)
* use hoe for build/release
* reworked generated examples for rspec_scaffold - thanks to Mikel Lindsaar and Dan Manges for their feedback
* bye, bye translator
* Added proxy to cookies so you can set them in examples the same way you set them in controllers
* Added script/autospec so you can run autospec without installing the gem
* Support --skip-fixture in the rspec_model generator (patches from Alex Tomlins and Niels Ganser)
* Add mock_model#as_new_record (patch from Zach Dennis)
* mock(:null_object=>true) plays nice with HTML (patch from Gerrit Kaiser)
* Suppress a deprecation notice in Rails 2.1 (James Herdman)
* quiet deprecation warning on inflector (RSL)
* rspec-rails gem (Ben Mabey)
* updated generated code examples
* Make rspec_model generator honour --skip-fixtures tag (Niels Ganser, Alex Tomlins)
* Fix to create new models with attributes in command line (Nicolas)
* fix to_param in mock_model with stubbed id incorrectly returning autogenerated id (Adam Meehan)
* Call Rail's TestCase setup/teardown callbacks (Jonathan del Strother)
* Only run TestUnitTesting once (Jonathan del Strother)
* use require_dependency instead of require (Brandon Keepers)
* Fixed a problem caused by controller action names getting out of sync between rspec-dev and rspec-rails for speccing (Matt Patterson)
* don't mutate hash passed to mock_model (Reg Vos)
=== Version 1.1.4
Maintenance release.
* Moved mock_model and stub_model to their own module: Spec::Rails::Mocks
* Setting mock_model object id with stubs hash - patch from Adam Meehan
* Added as_new_record to stub_model e.g. stub_model(Foo).as_new_record
* Improved stub_model such that new_record? does "the right thing"
* Patch from Pat Maddox to get integrate_views to work in nested example groups.
* Patch from Pat Maddox to get controller_name to work in nested example groups.
* Patch from Corey Haines to add include_text matcher
* Added stub_model method which creates a real model instance with :id stubbed and data access prohibited.
* Applied patch from Pat Maddox to handle redirect_to w/ SSL. Closes #320.
* Added #helper and #assigns to helper specs.
* Applied patch from Bryan Helmkamp to tweak format of generated spec.opts to be more obvious. Closes #162.
* Tweaked list of exceptions (ignores) for autotest
* Applied patch from Rick Olson to get rspec_on_rails working with rails edge (>= 8862)
* Applied patch from Wincent Colaiuta to invert sense of "spec --diff". Closes #281.
* Allow any type of render in view specs. Closes #57.
* Applied patch from Ian White to get rspec working with edge rails (8804). Closes #271.
* Applied patch from Jon Strother to have spec_server reload fixtures. Closes #344.

12
vendor/plugins/rspec-rails/MIT-LICENSE → vendor/plugins/rspec-rails/License.txt vendored
View file

@ -1,14 +1,16 @@
(The MIT License)
====================================================================
== RSpec
Copyright (c) 2005-2007 The RSpec Development Team
==== RSpec, RSpec-Rails
Copyright (c) 2005-2008 The RSpec Development Team
====================================================================
== ARTS
==== ARTS
Copyright (c) 2006 Kevin Clark, Jake Howerton
====================================================================
== ZenTest
==== ZenTest
Copyright (c) 2001-2006 Ryan Davis, Eric Hodel, Zen Spider Software
====================================================================
== AssertSelect
==== AssertSelect
Copyright (c) 2006 Assaf Arkin
====================================================================

159
vendor/plugins/rspec-rails/Manifest.txt vendored Normal file
View file

@ -0,0 +1,159 @@
History.txt
License.txt
Manifest.txt
README.txt
Rakefile
UPGRADE
generators/rspec/CHANGES
generators/rspec/rspec_generator.rb
generators/rspec/templates/all_stories.rb
generators/rspec/templates/previous_failures.txt
generators/rspec/templates/rcov.opts
generators/rspec/templates/rspec.rake
generators/rspec/templates/script/autospec
generators/rspec/templates/script/spec
generators/rspec/templates/script/spec_server
generators/rspec/templates/spec.opts
generators/rspec/templates/spec_helper.rb
generators/rspec/templates/stories_helper.rb
generators/rspec_controller/USAGE
generators/rspec_controller/rspec_controller_generator.rb
generators/rspec_controller/templates/controller_spec.rb
generators/rspec_controller/templates/helper_spec.rb
generators/rspec_controller/templates/view_spec.rb
generators/rspec_default_values.rb
generators/rspec_model/USAGE
generators/rspec_model/rspec_model_generator.rb
generators/rspec_model/templates/model_spec.rb
generators/rspec_scaffold/rspec_scaffold_generator.rb
generators/rspec_scaffold/templates/controller_spec.rb
generators/rspec_scaffold/templates/edit_erb_spec.rb
generators/rspec_scaffold/templates/helper_spec.rb
generators/rspec_scaffold/templates/index_erb_spec.rb
generators/rspec_scaffold/templates/new_erb_spec.rb
generators/rspec_scaffold/templates/routing_spec.rb
generators/rspec_scaffold/templates/show_erb_spec.rb
init.rb
lib/autotest/discover.rb
lib/autotest/rails_rspec.rb
lib/spec/rails.rb
lib/spec/rails/example.rb
lib/spec/rails/example/assigns_hash_proxy.rb
lib/spec/rails/example/controller_example_group.rb
lib/spec/rails/example/cookies_proxy.rb
lib/spec/rails/example/functional_example_group.rb
lib/spec/rails/example/helper_example_group.rb
lib/spec/rails/example/model_example_group.rb
lib/spec/rails/example/rails_example_group.rb
lib/spec/rails/example/render_observer.rb
lib/spec/rails/example/view_example_group.rb
lib/spec/rails/extensions.rb
lib/spec/rails/extensions/action_controller/base.rb
lib/spec/rails/extensions/action_controller/rescue.rb
lib/spec/rails/extensions/action_controller/test_response.rb
lib/spec/rails/extensions/action_view/base.rb
lib/spec/rails/extensions/active_record/base.rb
lib/spec/rails/extensions/object.rb
lib/spec/rails/extensions/spec/example/configuration.rb
lib/spec/rails/extensions/spec/matchers/have.rb
lib/spec/rails/interop/testcase.rb
lib/spec/rails/matchers.rb
lib/spec/rails/matchers/assert_select.rb
lib/spec/rails/matchers/change.rb
lib/spec/rails/matchers/have_text.rb
lib/spec/rails/matchers/include_text.rb
lib/spec/rails/matchers/redirect_to.rb
lib/spec/rails/matchers/render_template.rb
lib/spec/rails/mocks.rb
lib/spec/rails/story_adapter.rb
lib/spec/rails/version.rb
spec/rails/autotest/mappings_spec.rb
spec/rails/example/assigns_hash_proxy_spec.rb
spec/rails/example/configuration_spec.rb
spec/rails/example/controller_isolation_spec.rb
spec/rails/example/controller_spec_spec.rb
spec/rails/example/cookies_proxy_spec.rb
spec/rails/example/example_group_factory_spec.rb
spec/rails/example/helper_spec_spec.rb
spec/rails/example/model_spec_spec.rb
spec/rails/example/shared_behaviour_spec.rb
spec/rails/example/test_unit_assertion_accessibility_spec.rb
spec/rails/example/view_spec_spec.rb
spec/rails/extensions/action_controller_rescue_action_spec.rb
spec/rails/extensions/action_view_base_spec.rb
spec/rails/extensions/active_record_spec.rb
spec/rails/interop/testcase_spec.rb
spec/rails/matchers/assert_select_spec.rb
spec/rails/matchers/description_generation_spec.rb
spec/rails/matchers/errors_on_spec.rb
spec/rails/matchers/have_text_spec.rb
spec/rails/matchers/include_text_spec.rb
spec/rails/matchers/redirect_to_spec.rb
spec/rails/matchers/render_template_spec.rb
spec/rails/matchers/should_change_spec.rb
spec/rails/mocks/ar_classes.rb
spec/rails/mocks/mock_model_spec.rb
spec/rails/mocks/stub_model_spec.rb
spec/rails/sample_modified_fixture.rb
spec/rails/sample_spec.rb
spec/rails/spec_server_spec.rb
spec/rails/spec_spec.rb
spec/rails_suite.rb
spec/spec_helper.rb
spec_resources/controllers/action_view_base_spec_controller.rb
spec_resources/controllers/controller_spec_controller.rb
spec_resources/controllers/redirect_spec_controller.rb
spec_resources/controllers/render_spec_controller.rb
spec_resources/controllers/rjs_spec_controller.rb
spec_resources/helpers/explicit_helper.rb
spec_resources/helpers/more_explicit_helper.rb
spec_resources/helpers/plugin_application_helper.rb
spec_resources/helpers/view_spec_helper.rb
spec_resources/views/controller_spec/_partial.rhtml
spec_resources/views/controller_spec/action_setting_flash_after_session_reset.rhtml
spec_resources/views/controller_spec/action_setting_flash_before_session_reset.rhtml
spec_resources/views/controller_spec/action_setting_the_assigns_hash.rhtml
spec_resources/views/controller_spec/action_with_errors_in_template.rhtml
spec_resources/views/controller_spec/action_with_template.rhtml
spec_resources/views/layouts/application.rhtml
spec_resources/views/layouts/simple.rhtml
spec_resources/views/objects/_object.html.erb
spec_resources/views/render_spec/_a_partial.rhtml
spec_resources/views/render_spec/action_with_alternate_layout.rhtml
spec_resources/views/render_spec/some_action.js.rjs
spec_resources/views/render_spec/some_action.rhtml
spec_resources/views/render_spec/some_action.rjs
spec_resources/views/rjs_spec/_replacement_partial.rhtml
spec_resources/views/rjs_spec/hide_div.rjs
spec_resources/views/rjs_spec/hide_page_element.rjs
spec_resources/views/rjs_spec/insert_html.rjs
spec_resources/views/rjs_spec/replace.rjs
spec_resources/views/rjs_spec/replace_html.rjs
spec_resources/views/rjs_spec/replace_html_with_partial.rjs
spec_resources/views/rjs_spec/visual_effect.rjs
spec_resources/views/rjs_spec/visual_toggle_effect.rjs
spec_resources/views/tag_spec/no_tags.rhtml
spec_resources/views/tag_spec/single_div_with_no_attributes.rhtml
spec_resources/views/tag_spec/single_div_with_one_attribute.rhtml
spec_resources/views/view_spec/_partial.rhtml
spec_resources/views/view_spec/_partial_used_twice.rhtml
spec_resources/views/view_spec/_partial_with_local_variable.rhtml
spec_resources/views/view_spec/_partial_with_sub_partial.rhtml
spec_resources/views/view_spec/_spacer.rhtml
spec_resources/views/view_spec/accessor.rhtml
spec_resources/views/view_spec/block_helper.rhtml
spec_resources/views/view_spec/entry_form.rhtml
spec_resources/views/view_spec/explicit_helper.rhtml
spec_resources/views/view_spec/foo/show.rhtml
spec_resources/views/view_spec/implicit_helper.rhtml
spec_resources/views/view_spec/multiple_helpers.rhtml
spec_resources/views/view_spec/should_not_receive.rhtml
spec_resources/views/view_spec/template_with_partial.rhtml
spec_resources/views/view_spec/template_with_partial_using_collection.rhtml
spec_resources/views/view_spec/template_with_partial_with_array.rhtml
stories/all.rb
stories/configuration/stories.rb
stories/helper.rb
stories/steps/people.rb
stories/transactions_should_rollback
stories/transactions_should_rollback.rb

3
vendor/plugins/rspec-rails/README vendored
View file

@ -1,3 +0,0 @@
See the rdoc for Spec::Rails for usage documentation.
See ~/rspec/README for instructions on running rspec_on_rails' examples.

46
vendor/plugins/rspec-rails/README.txt vendored Normal file
View file

@ -0,0 +1,46 @@
= Spec::Rails
* http://rspec.info
* http://rspec.info/rdoc-rails/
* http://rubyforge.org/projects/rspec
* http://github.com/dchelimsky/rspec-rails/wikis
* mailto:rspec-devel@rubyforge.org
== DESCRIPTION:
Behaviour Driven Development for Ruby on Rails.
Spec::Rails (a.k.a. RSpec on Rails) is a Ruby on Rails plugin that allows you
to drive the development of your RoR application using RSpec, a framework that
aims to enable Example Driven Development in Ruby.
== FEATURES:
* Use RSpec to independently specify Rails Models, Views, Controllers and Helpers
* Integrated fixture loading
* Special generators for Resources, Models, Views and Controllers that generate Specs instead of Tests.
== VISION:
For people for whom TDD is a brand new concept, the testing support built into
Ruby on Rails is a huge leap forward. The fact that it is built right in is
fantastic, and Ruby on Rails apps are generally much easier to maintain than
they might have been without such support.
For those of us coming from a history with TDD, and now BDD, the existing
support presents some problems related to dependencies across examples. To
that end, RSpec on Rails supports 4 types of examples. We’ve also built in
first class mocking and stubbing support in order to break dependencies across
these different concerns.
== MORE INFORMATION:
See Spec::Rails::Runner for information about the different kinds of example
groups you can use to spec the different Rails components
See Spec::Rails::Expectations for information about Rails-specific
expectations you can set on responses and models, etc.
== INSTALL
* Visit http://github.com/dchelimsky/rspec-rails/wikis for installation instructions.

44
vendor/plugins/rspec-rails/Rakefile vendored
View file

@ -1,9 +1,39 @@
require 'rake'
require 'rake/rdoctask'
require 'rubygems'
require 'hoe'
require './lib/spec/rails/version'
desc 'Generate RDoc'
rd = Rake::RDocTask.new do |rdoc|
rdoc.rdoc_dir = '../doc/output/rdoc-rails'
rdoc.options << '--title' << 'Spec::Rails' << '--line-numbers' << '--inline-source' << '--main' << 'Spec::Rails'
rdoc.rdoc_files.include('MIT-LICENSE', 'lib/**/*.rb')
class Hoe
def extra_deps
@extra_deps.reject! { |x| Array(x).first == 'hoe' }
@extra_deps
end
end
Hoe.new('rspec-rails', Spec::Rails::VERSION::STRING) do |p|
p.summary = Spec::Rails::VERSION::SUMMARY
p.url = 'http://rspec.info/'
p.description = "Behaviour Driven Development for Ruby on Rails."
p.rubyforge_name = 'rspec'
p.developer('RSpec Development Team', 'rspec-devel@rubyforge.org')
p.extra_deps = [["rspec","1.1.8"]]
p.remote_rdoc_dir = "rspec-rails/#{Spec::Rails::VERSION::STRING}"
end
['audit','test','test_deps','default','post_blog', 'release'].each do |task|
Rake.application.instance_variable_get('@tasks').delete(task)
end
task :release => [:clean, :package] do |t|
version = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
abort "Versions don't match #{version} vs #{Spec::Rails::VERSION::STRING}" unless version == Spec::Rails::VERSION::STRING
pkg = "pkg/rspec-rails-#{version}"
rubyforge = RubyForge.new.configure
puts "Logging in to rubyforge ..."
rubyforge.login
puts "Releasing rspec-rails version #{version} ..."
["#{pkg}.gem", "#{pkg}.tgz"].each do |file|
rubyforge.add_file('rspec', 'rspec', Spec::Rails::VERSION::STRING, file)
end
end

4
vendor/plugins/rspec/UPGRADE → vendor/plugins/rspec-rails/UPGRADE vendored
View file

@ -1,7 +1,7 @@
== Spec::Rails
== Upgrade
script/generate rspec
Or modify spec_helper.rb based on the template, which can be found at:
vendor/plugins/rspec_on_rails/generators/rspec/templates/spec_helper.rb
vendor/plugins/rspec-rails/generators/rspec/templates/spec_helper.rb

15
vendor/plugins/rspec-rails/generators/rspec/rspec_generator.rb vendored
View file

@ -6,6 +6,7 @@ class RspecGenerator < Rails::Generator::Base
Config::CONFIG['ruby_install_name'])
def initialize(runtime_args, runtime_options = {})
Dir.mkdir('lib/tasks') unless File.directory?('lib/tasks')
super
end
@ -13,12 +14,16 @@ class RspecGenerator < Rails::Generator::Base
record do |m|
script_options = { :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang] }
m.directory 'spec'
m.template 'spec_helper.rb', 'spec/spec_helper.rb'
m.file 'spec.opts', 'spec/spec.opts'
m.file 'rcov.opts', 'spec/rcov.opts'
m.file 'script/spec_server', 'script/spec_server', script_options
m.file 'rspec.rake', 'lib/tasks/rspec.rake'
m.file 'script/autospec', 'script/autospec', script_options
m.file 'script/spec', 'script/spec', script_options
m.file 'script/spec_server', 'script/spec_server', script_options
m.directory 'spec'
m.file 'rcov.opts', 'spec/rcov.opts'
m.file 'spec.opts', 'spec/spec.opts'
m.template 'spec_helper.rb', 'spec/spec_helper.rb'
m.directory 'stories'
m.file 'all_stories.rb', 'stories/all.rb'

13
vendor/plugins/rspec-rails/tasks/rspec.rake → vendor/plugins/rspec-rails/generators/rspec/templates/rspec.rake vendored
View file

@ -1,10 +1,12 @@
raise "To avoid rake task loading problems: run 'rake clobber' in vendor/plugins/rspec" if File.directory?(File.join(File.dirname(__FILE__), *%w[.. .. vendor plugins rspec pkg]))
raise "To avoid rake task loading problems: run 'rake clobber' in vendor/plugins/rspec-rails" if File.directory?(File.join(File.dirname(__FILE__), *%w[.. .. vendor plugins rspec-rails pkg]))
# In rails 1.2, plugins aren't available in the path until they're loaded.
# Check to see if the rspec plugin is installed first and require
# it if it is. If not, use the gem version.
rspec_base = File.expand_path(File.dirname(__FILE__) + '/../../rspec/lib')
rspec_base = File.expand_path(File.dirname(__FILE__) + '/../../vendor/plugins/rspec/lib')
$LOAD_PATH.unshift(rspec_base) if File.exist?(rspec_base)
require 'spec/rake/spectask'
require 'spec/translator'
spec_prereq = File.exist?(File.join(RAILS_ROOT, 'config', 'database.yml')) ? "db:test:prepare" : :noop
task :noop do
@ -64,13 +66,6 @@ namespace :spec do
end
end
desc "Translate/upgrade specs using the built-in translator"
task :translate do
translator = ::Spec::Translator.new
dir = RAILS_ROOT + '/spec'
translator.translate(dir, dir)
end
# Setup specs for stats
task :statsetup do
require 'code_statistics'

4
vendor/plugins/rspec-rails/generators/rspec/templates/script/autospec vendored Normal file
View file

@ -0,0 +1,4 @@
#!/usr/bin/env ruby
ENV['RSPEC'] = 'true' # allows autotest to discover rspec
ENV['AUTOTEST'] = 'true' # allows autotest to run w/ color on linux
system (RUBY_PLATFORM =~ /mswin|mingw/ ? 'autotest.bat' : 'autotest'), *ARGV

1
vendor/plugins/rspec-rails/generators/rspec/templates/script/spec vendored
View file

@ -1,4 +1,5 @@
#!/usr/bin/env ruby
$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/rspec/lib"))
require 'rubygems'
require 'spec'
exit ::Spec::Runner::CommandLine.run(::Spec::Runner::OptionParser.parse(ARGV, STDERR, STDOUT))

19
vendor/plugins/rspec-rails/generators/rspec_default_values.rb vendored Normal file
View file

@ -0,0 +1,19 @@
module Rails
module Generator
class GeneratedAttribute
def default_value
@default_value ||= case type
when :int, :integer then "\"1\""
when :float then "\"1.5\""
when :decimal then "\"9.99\""
when :datetime, :timestamp, :time then "Time.now"
when :date then "Date.today"
when :string, :text then "\"value for #{@name}\""
when :boolean then "false"
else
""
end
end
end
end
end

9
vendor/plugins/rspec-rails/generators/rspec_model/rspec_model_generator.rb vendored
View file

@ -1,4 +1,5 @@
require 'rails_generator/generators/components/model/model_generator'
require File.dirname(__FILE__) + '/../rspec_default_values'
class RspecModelGenerator < ModelGenerator
@ -11,12 +12,16 @@ class RspecModelGenerator < ModelGenerator
# Model, spec, and fixture directories.
m.directory File.join('app/models', class_path)
m.directory File.join('spec/models', class_path)
m.directory File.join('spec/fixtures', class_path)
unless options[:skip_fixture]
m.directory File.join('spec/fixtures', class_path)
end
# Model class, spec and fixtures.
m.template 'model:model.rb', File.join('app/models', class_path, "#{file_name}.rb")
m.template 'model:fixtures.yml', File.join('spec/fixtures', class_path, "#{table_name}.yml")
m.template 'model_spec.rb', File.join('spec/models', class_path, "#{file_name}_spec.rb")
unless options[:skip_fixture]
m.template 'model:fixtures.yml', File.join('spec/fixtures', "#{table_name}.yml")
end
unless options[:skip_migration]
m.migration_template 'model:migration.rb', 'db/migrate', :assigns => {

10
vendor/plugins/rspec-rails/generators/rspec_model/templates/model_spec.rb vendored
View file

@ -2,10 +2,14 @@ require File.expand_path(File.dirname(__FILE__) + '<%= '/..' * class_nesting_dep
describe <%= class_name %> do
before(:each) do
@<%= file_name %> = <%= class_name %>.new
@valid_attributes = {
<% attributes.each_with_index do |attribute, attribute_index| -%>
:<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == attributes.length - 1 ? '' : ','%>
<% end -%>
}
end
it "should be valid" do
@<%= file_name %>.should be_valid
it "should create a new instance given valid attributes" do
<%= class_name %>.create!(@valid_attributes)
end
end

17
vendor/plugins/rspec-rails/generators/rspec_scaffold/rspec_scaffold_generator.rb vendored
View file

@ -1,3 +1,5 @@
require File.dirname(__FILE__) + '/../rspec_default_values'
class RspecScaffoldGenerator < Rails::Generator::NamedBase
default_options :skip_migration => false
@ -140,21 +142,6 @@ end
module Rails
module Generator
class GeneratedAttribute
def default_value
@default_value ||= case type
when :int, :integer then "\"1\""
when :float then "\"1.5\""
when :decimal then "\"9.99\""
when :datetime, :timestamp, :time then "Time.now"
when :date then "Date.today"
when :string then "\"MyString\""
when :text then "\"MyText\""
when :boolean then "false"
else
""
end
end
def input_type
@input_type ||= case type
when :text then "textarea"

374
vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/controller_spec.rb vendored
View file

@ -1,313 +1,173 @@
require File.expand_path(File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../spec_helper')
describe <%= controller_class_name %>Controller do
describe "handling GET /<%= table_name %>" do
before(:each) do
@<%= file_name %> = mock_model(<%= class_name %>)
<%= class_name %>.stub!(:find).and_return([@<%= file_name %>])
end
def mock_<%= file_name %>(stubs={})
@mock_<%= file_name %> ||= mock_model(<%= class_name %>, stubs)
end
def do_get
describe "responding to GET index" do
it "should expose all <%= table_name.pluralize %> as @<%= table_name.pluralize %>" do
<%= class_name %>.should_receive(:find).with(:all).and_return([mock_<%= file_name %>])
get :index
end
it "should be successful" do
do_get
response.should be_success
assigns[:<%= table_name %>].should == [mock_<%= file_name %>]
end
it "should render index template" do
do_get
response.should render_template('index')
end
describe "with mime type of xml" do
it "should find all <%= table_name %>" do
<%= class_name %>.should_receive(:find).with(:all).and_return([@<%= file_name %>])
do_get
end
it "should assign the found <%= table_name %> for the view" do
do_get
assigns[:<%= table_name %>].should == [@<%= file_name %>]
it "should render all <%= table_name.pluralize %> as xml" do
request.env["HTTP_ACCEPT"] = "application/xml"
<%= class_name %>.should_receive(:find).with(:all).and_return(<%= file_name.pluralize %> = mock("Array of <%= class_name.pluralize %>"))
<%= file_name.pluralize %>.should_receive(:to_xml).and_return("generated XML")
get :index
response.body.should == "generated XML"
end
end
end
describe "handling GET /<%= table_name %>.xml" do
describe "responding to GET show" do
before(:each) do
@<%= file_name.pluralize %> = mock("Array of <%= class_name.pluralize %>", :to_xml => "XML")
<%= class_name %>.stub!(:find).and_return(@<%= file_name.pluralize %>)
end
def do_get
@request.env["HTTP_ACCEPT"] = "application/xml"
get :index
end
it "should be successful" do
do_get
response.should be_success
end
it "should find all <%= table_name %>" do
<%= class_name %>.should_receive(:find).with(:all).and_return(@<%= file_name.pluralize %>)
do_get
end
it "should render the found <%= table_name %> as xml" do
@<%= file_name.pluralize %>.should_receive(:to_xml).and_return("XML")
do_get
response.body.should == "XML"
end
end
describe "handling GET /<%= table_name %>/1" do
before(:each) do
@<%= file_name %> = mock_model(<%= class_name %>)
<%= class_name %>.stub!(:find).and_return(@<%= file_name %>)
end
def do_get
get :show, :id => "1"
end
it "should be successful" do
do_get
response.should be_success
end
it "should render show template" do
do_get
response.should render_template('show')
end
it "should find the <%= file_name %> requested" do
<%= class_name %>.should_receive(:find).with("1").and_return(@<%= file_name %>)
do_get
end
it "should assign the found <%= file_name %> for the view" do
do_get
assigns[:<%= file_name %>].should equal(@<%= file_name %>)
end
end
describe "handling GET /<%= table_name %>/1.xml" do
before(:each) do
@<%= file_name %> = mock_model(<%= class_name %>, :to_xml => "XML")
<%= class_name %>.stub!(:find).and_return(@<%= file_name %>)
end
def do_get
@request.env["HTTP_ACCEPT"] = "application/xml"
get :show, :id => "1"
end
it "should be successful" do
do_get
response.should be_success
end
it "should find the <%= file_name %> requested" do
<%= class_name %>.should_receive(:find).with("1").and_return(@<%= file_name %>)
do_get
end
it "should render the found <%= file_name %> as xml" do
@<%= file_name %>.should_receive(:to_xml).and_return("XML")
do_get
response.body.should == "XML"
end
end
describe "handling GET /<%= table_name %>/new" do
before(:each) do
@<%= file_name %> = mock_model(<%= class_name %>)
<%= class_name %>.stub!(:new).and_return(@<%= file_name %>)
end
def do_get
get :new
end
it "should be successful" do
do_get
response.should be_success
end
it "should render new template" do
do_get
response.should render_template('new')
end
it "should create an new <%= file_name %>" do
<%= class_name %>.should_receive(:new).and_return(@<%= file_name %>)
do_get
end
it "should not save the new <%= file_name %>" do
@<%= file_name %>.should_not_receive(:save)
do_get
end
it "should assign the new <%= file_name %> for the view" do
do_get
assigns[:<%= file_name %>].should equal(@<%= file_name %>)
end
end
describe "handling GET /<%= table_name %>/1/edit" do
before(:each) do
@<%= file_name %> = mock_model(<%= class_name %>)
<%= class_name %>.stub!(:find).and_return(@<%= file_name %>)
end
def do_get
get :edit, :id => "1"
end
it "should be successful" do
do_get
response.should be_success
end
it "should render edit template" do
do_get
response.should render_template('edit')
end
it "should find the <%= file_name %> requested" do
<%= class_name %>.should_receive(:find).and_return(@<%= file_name %>)
do_get
end
it "should assign the found <%= class_name %> for the view" do
do_get
assigns[:<%= file_name %>].should equal(@<%= file_name %>)
end
end
describe "handling POST /<%= table_name %>" do
before(:each) do
@<%= file_name %> = mock_model(<%= class_name %>, :to_param => "1")
<%= class_name %>.stub!(:new).and_return(@<%= file_name %>)
it "should expose the requested <%= file_name %> as @<%= file_name %>" do
<%= class_name %>.should_receive(:find).with("37").and_return(mock_<%= file_name %>)
get :show, :id => "37"
assigns[:<%= file_name %>].should equal(mock_<%= file_name %>)
end
describe "with successful save" do
def do_post
@<%= file_name %>.should_receive(:save).and_return(true)
post :create, :<%= file_name %> => {}
end
it "should create a new <%= file_name %>" do
<%= class_name %>.should_receive(:new).with({}).and_return(@<%= file_name %>)
do_post
describe "with mime type of xml" do
it "should render the requested <%= file_name %> as xml" do
request.env["HTTP_ACCEPT"] = "application/xml"
<%= class_name %>.should_receive(:find).with("37").and_return(mock_<%= file_name %>)
mock_<%= file_name %>.should_receive(:to_xml).and_return("generated XML")
get :show, :id => "37"
response.body.should == "generated XML"
end
it "should redirect to the new <%= file_name %>" do
do_post
response.should redirect_to(<%= table_name.singularize %>_url("1"))
end
end
describe "responding to GET new" do
it "should expose a new <%= file_name %> as @<%= file_name %>" do
<%= class_name %>.should_receive(:new).and_return(mock_<%= file_name %>)
get :new
assigns[:<%= file_name %>].should equal(mock_<%= file_name %>)
end
end
describe "responding to GET edit" do
it "should expose the requested <%= file_name %> as @<%= file_name %>" do
<%= class_name %>.should_receive(:find).with("37").and_return(mock_<%= file_name %>)
get :edit, :id => "37"
assigns[:<%= file_name %>].should equal(mock_<%= file_name %>)
end
end
describe "responding to POST create" do
describe "with valid params" do
it "should expose a newly created <%= file_name %> as @<%= file_name %>" do
<%= class_name %>.should_receive(:new).with({'these' => 'params'}).and_return(mock_<%= file_name %>(:save => true))
post :create, :<%= file_name %> => {:these => 'params'}
assigns(:<%= file_name %>).should equal(mock_<%= file_name %>)
end
it "should redirect to the created <%= file_name %>" do
<%= class_name %>.stub!(:new).and_return(mock_<%= file_name %>(:save => true))
post :create, :<%= file_name %> => {}
response.should redirect_to(<%= table_name.singularize %>_url(mock_<%= file_name %>))
end
end
describe "with failed save" do
describe "with invalid params" do
def do_post
@<%= file_name %>.should_receive(:save).and_return(false)
post :create, :<%= file_name %> => {}
it "should expose a newly created but unsaved <%= file_name %> as @<%= file_name %>" do
<%= class_name %>.stub!(:new).with({'these' => 'params'}).and_return(mock_<%= file_name %>(:save => false))
post :create, :<%= file_name %> => {:these => 'params'}
assigns(:<%= file_name %>).should equal(mock_<%= file_name %>)
end
it "should re-render 'new'" do
do_post
it "should re-render the 'new' template" do
<%= class_name %>.stub!(:new).and_return(mock_<%= file_name %>(:save => false))
post :create, :<%= file_name %> => {}
response.should render_template('new')
end
end
end
describe "handling PUT /<%= table_name %>/1" do
describe "responding to PUT udpate" do
before(:each) do
@<%= file_name %> = mock_model(<%= class_name %>, :to_param => "1")
<%= class_name %>.stub!(:find).and_return(@<%= file_name %>)
end
describe "with successful update" do
describe "with valid params" do
def do_put
@<%= file_name %>.should_receive(:update_attributes).and_return(true)
it "should update the requested <%= file_name %>" do
<%= class_name %>.should_receive(:find).with("37").and_return(mock_<%= file_name %>)
mock_<%= file_name %>.should_receive(:update_attributes).with({'these' => 'params'})
put :update, :id => "37", :<%= file_name %> => {:these => 'params'}
end
it "should expose the requested <%= file_name %> as @<%= file_name %>" do
<%= class_name %>.stub!(:find).and_return(mock_<%= file_name %>(:update_attributes => true))
put :update, :id => "1"
end
it "should find the <%= file_name %> requested" do
<%= class_name %>.should_receive(:find).with("1").and_return(@<%= file_name %>)
do_put
end
it "should update the found <%= file_name %>" do
do_put
assigns(:<%= file_name %>).should equal(@<%= file_name %>)
end
it "should assign the found <%= file_name %> for the view" do
do_put
assigns(:<%= file_name %>).should equal(@<%= file_name %>)
assigns(:<%= file_name %>).should equal(mock_<%= file_name %>)
end
it "should redirect to the <%= file_name %>" do
do_put
response.should redirect_to(<%= table_name.singularize %>_url("1"))
<%= class_name %>.stub!(:find).and_return(mock_<%= file_name %>(:update_attributes => true))
put :update, :id => "1"
response.should redirect_to(<%= table_name.singularize %>_url(mock_<%= file_name %>))
end
end
describe "with failed update" do
describe "with invalid params" do
def do_put
@<%= file_name %>.should_receive(:update_attributes).and_return(false)
put :update, :id => "1"
it "should update the requested <%= file_name %>" do
<%= class_name %>.should_receive(:find).with("37").and_return(mock_<%= file_name %>)
mock_<%= file_name %>.should_receive(:update_attributes).with({'these' => 'params'})
put :update, :id => "37", :<%= file_name %> => {:these => 'params'}
end
it "should re-render 'edit'" do
do_put
it "should expose the <%= file_name %> as @<%= file_name %>" do
<%= class_name %>.stub!(:find).and_return(mock_<%= file_name %>(:update_attributes => false))
put :update, :id => "1"
assigns(:<%= file_name %>).should equal(mock_<%= file_name %>)
end
it "should re-render the 'edit' template" do
<%= class_name %>.stub!(:find).and_return(mock_<%= file_name %>(:update_attributes => false))
put :update, :id => "1"
response.should render_template('edit')
end
end
end
describe "handling DELETE /<%= table_name %>/1" do
describe "responding to DELETE destroy" do
before(:each) do
@<%= file_name %> = mock_model(<%= class_name %>, :destroy => true)
<%= class_name %>.stub!(:find).and_return(@<%= file_name %>)
end
def do_delete
delete :destroy, :id => "1"
end
it "should find the <%= file_name %> requested" do
<%= class_name %>.should_receive(:find).with("1").and_return(@<%= file_name %>)
do_delete
end
it "should call destroy on the found <%= file_name %>" do
@<%= file_name %>.should_receive(:destroy)
do_delete
it "should destroy the requested <%= file_name %>" do
<%= class_name %>.should_receive(:find).with("37").and_return(mock_<%= file_name %>)
mock_<%= file_name %>.should_receive(:destroy)
delete :destroy, :id => "37"
end
it "should redirect to the <%= table_name %> list" do
do_delete
<%= class_name %>.stub!(:find).and_return(mock_<%= file_name %>(:destroy => true))
delete :destroy, :id => "1"
response.should redirect_to(<%= table_name %>_url)
end
end
end

13
vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/edit_erb_spec.rb vendored
View file

@ -3,12 +3,13 @@ require File.expand_path(File.dirname(__FILE__) + '<%= '/..' * class_nesting_dep
describe "/<%= table_name %>/edit.<%= default_file_extension %>" do
include <%= controller_class_name %>Helper
before do
@<%= file_name %> = mock_model(<%= class_name %>)
<% for attribute in attributes -%>
@<%= file_name %>.stub!(:<%= attribute.name %>).and_return(<%= attribute.default_value %>)
<% end -%>
assigns[:<%= file_name %>] = @<%= file_name %>
before(:each) do
assigns[:<%= file_name %>] = @<%= file_name %> = stub_model(<%= class_name %>,
:new_record? => false<%= attributes.empty? ? '' : ',' %>
<% attributes.each_with_index do |attribute, attribute_index| -%><% unless attribute.name =~ /_id/ || [:datetime, :timestamp, :time, :date].index(attribute.type) -%>
:<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == attributes.length - 1 ? '' : ','%>
<% end -%><% end -%>
)
end
it "should render edit form" do

17
vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/index_erb_spec.rb vendored
View file

@ -4,12 +4,17 @@ describe "/<%= table_name %>/index.<%= default_file_extension %>" do
include <%= controller_class_name %>Helper
before(:each) do
<% [98,99].each do |id| -%>
<%= file_name %>_<%= id %> = mock_model(<%= class_name %>)
<% for attribute in attributes -%>
<%= file_name %>_<%= id %>.should_receive(:<%= attribute.name %>).and_return(<%= attribute.default_value %>)
<% end -%><% end %>
assigns[:<%= table_name %>] = [<%= file_name %>_98, <%= file_name %>_99]
assigns[:<%= table_name %>] = [
<% [1,2].each_with_index do |id, model_index| -%>
stub_model(<%= class_name %><%= attributes.empty? ? (model_index == 1 ? ')' : '),') : ',' %>
<% attributes.each_with_index do |attribute, attribute_index| -%><% unless attribute.name =~ /_id/ || [:datetime, :timestamp, :time, :date].index(attribute.type) -%>
:<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == attributes.length - 1 ? '' : ','%>
<% end -%><% end -%>
<% if !attributes.empty? -%>
<%= model_index == 1 ? ')' : '),' %>
<% end -%>
<% end -%>
]
end
it "should render list of <%= table_name %>" do

12
vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/new_erb_spec.rb vendored
View file

@ -4,12 +4,12 @@ describe "/<%= table_name %>/new.<%= default_file_extension %>" do
include <%= controller_class_name %>Helper
before(:each) do
@<%= file_name %> = mock_model(<%= class_name %>)
@<%= file_name %>.stub!(:new_record?).and_return(true)
<% for attribute in attributes -%>
@<%= file_name %>.stub!(:<%= attribute.name %>).and_return(<%= attribute.default_value %>)
<% end -%>
assigns[:<%= file_name %>] = @<%= file_name %>
assigns[:<%= file_name %>] = stub_model(<%= class_name %>,
:new_record? => true<%= attributes.empty? ? '' : ',' %>
<% attributes.each_with_index do |attribute, attribute_index| -%><% unless attribute.name =~ /_id/ || [:datetime, :timestamp, :time, :date].index(attribute.type) -%>
:<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == attributes.length - 1 ? '' : ','%>
<% end -%><% end -%>
)
end
it "should render new form" do

28
vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/routing_spec.rb vendored
View file

@ -2,59 +2,57 @@ require File.expand_path(File.dirname(__FILE__) + '<%= '/..' * class_nesting_dep
describe <%= controller_class_name %>Controller do
describe "route generation" do
it "should map { :controller => '<%= table_name %>', :action => 'index' } to /<%= table_name %>" do
it "should map #index" do
route_for(:controller => "<%= table_name %>", :action => "index").should == "/<%= table_name %>"
end
it "should map { :controller => '<%= table_name %>', :action => 'new' } to /<%= table_name %>/new" do
it "should map #new" do
route_for(:controller => "<%= table_name %>", :action => "new").should == "/<%= table_name %>/new"
end
it "should map { :controller => '<%= table_name %>', :action => 'show', :id => 1 } to /<%= table_name %>/1" do
it "should map #show" do
route_for(:controller => "<%= table_name %>", :action => "show", :id => 1).should == "/<%= table_name %>/1"
end
it "should map { :controller => '<%= table_name %>', :action => 'edit', :id => 1 } to /<%= table_name %>/1<%= resource_edit_path %>" do
it "should map #edit" do
route_for(:controller => "<%= table_name %>", :action => "edit", :id => 1).should == "/<%= table_name %>/1<%= resource_edit_path %>"
end
it "should map { :controller => '<%= table_name %>', :action => 'update', :id => 1} to /<%= table_name %>/1" do
it "should map #update" do
route_for(:controller => "<%= table_name %>", :action => "update", :id => 1).should == "/<%= table_name %>/1"
end
it "should map { :controller => '<%= table_name %>', :action => 'destroy', :id => 1} to /<%= table_name %>/1" do
it "should map #destroy" do
route_for(:controller => "<%= table_name %>", :action => "destroy", :id => 1).should == "/<%= table_name %>/1"
end
end
describe "route recognition" do
it "should generate params { :controller => '<%= table_name %>', action => 'index' } from GET /<%= table_name %>" do
it "should generate params for #index" do
params_from(:get, "/<%= table_name %>").should == {:controller => "<%= table_name %>", :action => "index"}
end
it "should generate params { :controller => '<%= table_name %>', action => 'new' } from GET /<%= table_name %>/new" do
it "should generate params for #new" do
params_from(:get, "/<%= table_name %>/new").should == {:controller => "<%= table_name %>", :action => "new"}
end
it "should generate params { :controller => '<%= table_name %>', action => 'create' } from POST /<%= table_name %>" do
it "should generate params for #create" do
params_from(:post, "/<%= table_name %>").should == {:controller => "<%= table_name %>", :action => "create"}
end
it "should generate params { :controller => '<%= table_name %>', action => 'show', id => '1' } from GET /<%= table_name %>/1" do
it "should generate params for #show" do
params_from(:get, "/<%= table_name %>/1").should == {:controller => "<%= table_name %>", :action => "show", :id => "1"}
end
it "should generate params { :controller => '<%= table_name %>', action => 'edit', id => '1' } from GET /<%= table_name %>/1;edit" do
it "should generate params for #edit" do
params_from(:get, "/<%= table_name %>/1<%= resource_edit_path %>").should == {:controller => "<%= table_name %>", :action => "edit", :id => "1"}
end
it "should generate params { :controller => '<%= table_name %>', action => 'update', id => '1' } from PUT /<%= table_name %>/1" do
it "should generate params for #update" do
params_from(:put, "/<%= table_name %>/1").should == {:controller => "<%= table_name %>", :action => "update", :id => "1"}
end
it "should generate params { :controller => '<%= table_name %>', action => 'destroy', id => '1' } from DELETE /<%= table_name %>/1" do
it "should generate params for #destroy" do
params_from(:delete, "/<%= table_name %>/1").should == {:controller => "<%= table_name %>", :action => "destroy", :id => "1"}
end
end

11
vendor/plugins/rspec-rails/generators/rspec_scaffold/templates/show_erb_spec.rb vendored
View file

@ -4,12 +4,13 @@ describe "/<%= table_name %>/show.<%= default_file_extension %>" do
include <%= controller_class_name %>Helper
before(:each) do
@<%= file_name %> = mock_model(<%= class_name %>)
<% for attribute in attributes -%>
@<%= file_name %>.stub!(:<%= attribute.name %>).and_return(<%= attribute.default_value %>)
assigns[:<%= file_name %>] = @<%= file_name %> = stub_model(<%= class_name %><%= attributes.empty? ? ')' : ',' %>
<% attributes.each_with_index do |attribute, attribute_index| -%><% unless attribute.name =~ /_id/ || [:datetime, :timestamp, :time, :date].index(attribute.type) -%>
:<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == attributes.length - 1 ? '' : ','%>
<% end -%><% end -%>
<% if !attributes.empty? -%>
)
<% end -%>
assigns[:<%= file_name %>] = @<%= file_name %>
end
it "should render attributes in <p>" do

5
vendor/plugins/rspec-rails/lib/autotest/rails_rspec.rb vendored
View file

@ -73,9 +73,4 @@ Autotest.add_hook :initialize do |at|
end
class Autotest::RailsRspec < Autotest::Rspec
def spec_command
"script/spec"
end
end

41
vendor/plugins/rspec-rails/lib/spec/rails.rb vendored
View file

@ -1,6 +1,6 @@
silence_warnings { RAILS_ENV = "test" }
require 'application'
require_dependency 'application'
require 'action_controller/test_process'
require 'action_controller/integration'
require 'active_record/fixtures' if defined?(ActiveRecord::Base)
@ -12,41 +12,4 @@ require 'spec/rails/matchers'
require 'spec/rails/mocks'
require 'spec/rails/example'
require 'spec/rails/extensions'
require 'spec/rails/version'
module Spec
# = Spec::Rails
#
# Spec::Rails (a.k.a. RSpec on Rails) is a Ruby on Rails plugin that allows you to drive the development
# of your RoR application using RSpec, a framework that aims to enable Example Driven Development
# in Ruby.
#
# == Features
#
# * Use RSpec to independently specify Rails Models, Views, Controllers and Helpers
# * Integrated fixture loading
# * Special generators for Resources, Models, Views and Controllers that generate Specs instead of Tests.
#
# == Vision
#
# For people for whom TDD is a brand new concept, the testing support built into Ruby on Rails
# is a huge leap forward. The fact that it is built right in is fantastic, and Ruby on Rails
# apps are generally much easier to maintain than they might have been without such support.
#
# For those of us coming from a history with TDD, and now BDD, the existing support presents some problems related to dependencies across specs. To that end, RSpec on Rails supports 4 types of specs. We’ve also built in first class mocking and stubbing support in order to break dependencies across these different concerns.
#
# == More Information
#
# See Spec::Rails::Runner for information about the different kinds of contexts
# you can use to spec the different Rails components
#
# See Spec::Rails::Expectations for information about Rails-specific expectations
# you can set on responses and models, etc.
#
# == License
#
# RSpec on Rails is licensed under the same license as RSpec itself,
# the MIT-LICENSE.
module Rails
end
end
require 'spec/rails/interop/testcase'

1
vendor/plugins/rspec-rails/lib/spec/rails/example.rb vendored
View file

@ -9,6 +9,7 @@ require "spec/rails/example/functional_example_group"
require "spec/rails/example/controller_example_group"
require "spec/rails/example/helper_example_group"
require "spec/rails/example/view_example_group"
require "spec/rails/example/cookies_proxy"
module Spec
module Rails

29
vendor/plugins/rspec-rails/lib/spec/rails/example/assigns_hash_proxy.rb vendored
View file

@ -2,27 +2,24 @@ module Spec
module Rails
module Example
class AssignsHashProxy #:nodoc:
def initialize(object)
@object = object
def initialize(example_group, &block)
@target = block.call
@example_group = example_group
end
def [](ivar)
if assigns.include?(ivar.to_s)
assigns[ivar.to_s]
elsif assigns.include?(ivar)
assigns[ivar]
else
nil
end
def [](key)
return false if assigns[key] == false
return false if assigns[key.to_s] == false
assigns[key] || assigns[key.to_s] || @target.instance_variable_get("@#{key}")
end
def []=(ivar, val)
@object.instance_variable_set "@#{ivar}", val
assigns[ivar.to_s] = val
def []=(key, val)
@target.instance_variable_set("@#{key}", val)
end
def delete(name)
assigns.delete(name.to_s)
def delete(key)
assigns.delete(key.to_s)
@target.instance_variable_set("@#{key}", nil)
end
def each(&block)
@ -35,7 +32,7 @@ module Spec
protected
def assigns
@object.assigns
@example_group.orig_assigns
end
end
end

63
vendor/plugins/rspec-rails/lib/spec/rails/example/controller_example_group.rb vendored
View file

@ -125,7 +125,7 @@ module Spec
attr_reader :response, :request, :controller
def initialize(defined_description, &implementation) #:nodoc:
def initialize(defined_description, options={}, &implementation) #:nodoc:
super
controller_class_name = self.class.controller_class_name
if controller_class_name
@ -158,7 +158,9 @@ module Spec
protected
def _assigns_hash_proxy
@_assigns_hash_proxy ||= AssignsHashProxy.new @controller
@_assigns_hash_proxy ||= AssignsHashProxy.new self do
@response.template
end
end
private
@ -183,61 +185,39 @@ module Spec
unless integrate_views?
if @template.respond_to?(:finder)
(class << @template.finder; self; end).class_eval do
define_method :file_exists? do
true
end
define_method :file_exists? do; true; end
end
else
(class << @template; self; end).class_eval do
define_method :file_exists? do
true
end
define_method :file_exists? do; true; end
end
end
(class << @template; self; end).class_eval do
define_method :render_file do |*args|
@first_render ||= args[0]
@first_render ||= args[0] unless args[0] =~ /^layouts/
@_first_render ||= args[0] unless args[0] =~ /^layouts/
end
define_method :_pick_template do |*args|
@_first_render ||= args[0] unless args[0] =~ /^layouts/
PickedTemplate.new
end
end
end
end
if matching_message_expectation_exists(options)
expect_render_mock_proxy.render(options, &block)
render_proxy.render(options, &block)
@performed_render = true
else
unless matching_stub_exists(options)
if matching_stub_exists(options)
@performed_render = true
else
super(options, deprecated_status_or_extra_options, &block)
end
end
end
def raise_with_disable_message(old_method, new_method)
raise %Q|
controller.#{old_method}(:render) has been disabled because it
can often produce unexpected results. Instead, you should
use the following (before the action):
controller.#{new_method}(*args)
See the rdoc for #{new_method} for more information.
|
end
def should_receive(*args)
if args[0] == :render
raise_with_disable_message("should_receive", "expect_render")
else
super
end
end
def stub!(*args)
if args[0] == :render
raise_with_disable_message("stub!", "stub_render")
else
super
end
end
def response(&block)
# NOTE - we're setting @update for the assert_select_spec - kinda weird, huh?
@update = block
@ -255,17 +235,22 @@ module Spec
end
def matching_message_expectation_exists(options)
expect_render_mock_proxy.send(:__mock_proxy).send(:find_matching_expectation, :render, options)
render_proxy.send(:__mock_proxy).send(:find_matching_expectation, :render, options)
end
def matching_stub_exists(options)
expect_render_mock_proxy.send(:__mock_proxy).send(:find_matching_method_stub, :render, options)
render_proxy.send(:__mock_proxy).send(:find_matching_method_stub, :render, options)
end
end
Spec::Example::ExampleGroupFactory.register(:controller, self)
end
class PickedTemplate
def render_template(*ignore_args); end
def render_partial(*ignore_args); end
end
end
end
end

25
vendor/plugins/rspec-rails/lib/spec/rails/example/cookies_proxy.rb vendored Normal file
View file

@ -0,0 +1,25 @@
require 'action_controller/cookies'
module Spec
module Rails
module Example
class CookiesProxy
def initialize(example)
@example = example
end
def[]=(name, value)
@example.request.cookies[name.to_s] = CGI::Cookie.new(name.to_s, value)
end
def [](name)
@example.response.cookies[name.to_s]
end
def delete(name)
@example.response.cookies.delete(name.to_s)
end
end
end
end
end

28
vendor/plugins/rspec-rails/lib/spec/rails/example/functional_example_group.rb vendored
View file

@ -27,6 +27,33 @@ module Spec
def session
response.session
end
# Overrides the <tt>cookies()</tt> method in
# ActionController::TestResponseBehaviour, returning a proxy that
# accesses the requests cookies when setting a cookie and the
# responses cookies when reading one. This allows you to set and read
# cookies in examples using the same API with which you set and read
# them in controllers.
#
# == Examples (Rails >= 1.2.6)
#
# cookies[:user_id] = '1234'
# get :index
# assigns[:user].id.should == '1234'
#
# post :login
# cookies[:login].expires.should == 1.week.from_now
#
# == Examples (Rails >= 2.0.0 only)
#
# cookies[:user_id] = {:value => '1234', :expires => 1.minute.ago}
# get :index
# response.should be_redirect
def cookies
@cookies ||= Spec::Rails::Example::CookiesProxy.new(self)
end
alias_method :orig_assigns, :assigns
# :call-seq:
# assigns()
@ -53,6 +80,7 @@ module Spec
_assigns_hash_proxy[key]
end
end
end
end
end

4
vendor/plugins/rspec-rails/lib/spec/rails/example/helper_example_group.rb vendored
View file

@ -148,7 +148,9 @@ module Spec
protected
def _assigns_hash_proxy
@_assigns_hash_proxy ||= AssignsHashProxy.new helper
@_assigns_hash_proxy ||= AssignsHashProxy.new self do
helper
end
end
end

14
vendor/plugins/rspec-rails/lib/spec/rails/example/rails_example_group.rb vendored
View file

@ -11,11 +11,15 @@ module Spec
class RailsExampleGroup < Test::Unit::TestCase
# Rails >= r8570 uses setup/teardown_fixtures explicitly
before(:each) do
setup_fixtures if self.respond_to?(:setup_fixtures)
end
after(:each) do
teardown_fixtures if self.respond_to?(:teardown_fixtures)
# However, Rails >= r8664 extracted these out to use ActiveSupport::Callbacks.
# The latter case is handled at the TestCase level, in interop/testcase.rb
unless ActiveSupport.const_defined?(:Callbacks) and self.include?(ActiveSupport::Callbacks)
before(:each) do
setup_fixtures if self.respond_to?(:setup_fixtures)
end
after(:each) do
teardown_fixtures if self.respond_to?(:teardown_fixtures)
end
end
include Spec::Rails::Matchers

95
vendor/plugins/rspec-rails/lib/spec/rails/example/render_observer.rb vendored
View file

@ -3,61 +3,39 @@ require 'spec/mocks/framework'
module Spec
module Rails
module Example
# Provides specialized mock-like behaviour for controller and view examples,
# allowing you to mock or stub calls to render with specific arguments while
# ignoring all other calls.
# Extends the #should_receive, #should_not_receive and #stub! methods in rspec's
# mocking framework to handle #render calls to controller in controller examples
# and template and view examples
module RenderObserver
# Similar to mocking +render+ with the exception that calls to +render+ with
# any other options are passed on to the receiver (i.e. controller in
# controller examples, template in view examples).
#
# This is necessary because Rails uses the +render+ method on both
# controllers and templates as a dispatcher to render different kinds of
# things, sometimes resulting in many calls to the render method within one
# request. This approach makes it impossible to use a normal mock object, which
# is designed to observe all incoming messages with a given name.
#
# +expect_render+ is auto-verifying, so failures will be reported without
# requiring you to explicitly request verification.
#
# Also, +expect_render+ uses parts of RSpec's mock expectation framework. Because
# it wraps only a subset of the framework, using this will create no conflict with
# other mock frameworks if you choose to use them. Additionally, the object returned
# by expect_render is an RSpec mock object, which means that you can call any of the
# chained methods available in RSpec's mocks.
#
# == Controller Examples
#
# controller.expect_render(:partial => 'thing', :object => thing)
# controller.expect_render(:partial => 'thing', :collection => things).once
#
# controller.stub_render(:partial => 'thing', :object => thing)
# controller.stub_render(:partial => 'thing', :collection => things).twice
#
# == View Examples
#
# template.expect_render(:partial => 'thing', :object => thing)
# template.expect_render(:partial => 'thing', :collection => things)
#
# template.stub_render(:partial => 'thing', :object => thing)
# template.stub_render(:partial => 'thing', :collection => things)
# DEPRECATED
#
# Use should_receive(:render).with(opts) instead
def expect_render(opts={})
warn_deprecation("expect_render", "should_receive")
register_verify_after_each
expect_render_mock_proxy.should_receive(:render, :expected_from => caller(1)[0]).with(opts)
render_proxy.should_receive(:render, :expected_from => caller(1)[0]).with(opts)
end
# This is exactly like expect_render, with the exception that the call to render will not
# be verified. Use this if you are trying to isolate your example from a complicated render
# operation but don't care whether it is called or not.
# DEPRECATED
#
# Use stub!(:render).with(opts) instead
def stub_render(opts={})
warn_deprecation("stub_render", "stub!")
register_verify_after_each
expect_render_mock_proxy.stub!(:render, :expected_from => caller(1)[0]).with(opts)
render_proxy.stub!(:render, :expected_from => caller(1)[0]).with(opts)
end
def warn_deprecation(deprecated_method, new_method)
Kernel.warn <<-WARNING
#{deprecated_method} is deprecated and will be removed from a future version of rspec-rails.
Please just use object.#{new_method} instead.
WARNING
end
def verify_rendered # :nodoc:
expect_render_mock_proxy.rspec_verify
render_proxy.rspec_verify
end
def unregister_verify_after_each #:nodoc:
@ -65,7 +43,32 @@ module Spec
Spec::Example::ExampleGroup.remove_after(:each, &proc)
end
protected
def should_receive(*args)
if args[0] == :render
register_verify_after_each
render_proxy.should_receive(:render, :expected_from => caller(1)[0])
else
super
end
end
def should_not_receive(*args)
if args[0] == :render
register_verify_after_each
render_proxy.should_not_receive(:render)
else
super
end
end
def stub!(*args)
if args[0] == :render
register_verify_after_each
render_proxy.stub!(:render, :expected_from => caller(1)[0])
else
super
end
end
def verify_rendered_proc #:nodoc:
template = self
@ -80,8 +83,8 @@ module Spec
Spec::Example::ExampleGroup.after(:each, &proc)
end
def expect_render_mock_proxy #:nodoc:
@expect_render_mock_proxy ||= Spec::Mocks::Mock.new("expect_render_mock_proxy")
def render_proxy #:nodoc:
@render_proxy ||= Spec::Mocks::Mock.new("render_proxy")
end
end

9
vendor/plugins/rspec-rails/lib/spec/rails/example/view_example_group.rb vendored
View file

@ -32,7 +32,7 @@ module Spec
ensure_that_base_view_path_is_not_set_across_example_groups
end
def initialize(defined_description, &implementation) #:nodoc:
def initialize(defined_description, options={}, &implementation) #:nodoc:
super
@controller_class_name = "Spec::Rails::Example::ViewExampleGroupController"
end
@ -150,7 +150,9 @@ module Spec
protected
def _assigns_hash_proxy
@_assigns_hash_proxy ||= AssignsHashProxy.new @controller
@_assigns_hash_proxy ||= AssignsHashProxy.new self do
@response.template
end
end
end
@ -172,6 +174,9 @@ module Spec
include helper_module
end
end
def forget_variables_added_to_assigns
end
end
end
end

12
vendor/plugins/rspec-rails/lib/spec/rails/extensions/action_view/base.rb vendored
View file

@ -10,15 +10,19 @@ module ActionView #:nodoc:
end
end
end
super(partial_path, local_assigns, deprecated_local_assigns)
begin
super(partial_path, local_assigns, deprecated_local_assigns)
rescue ArgumentError # edge rails > 2.1 changed render_partial to accept only one arg
super(partial_path)
end
end
alias_method :orig_render, :render
def render(options = {}, old_local_assigns = {}, &block)
if expect_render_mock_proxy.send(:__mock_proxy).send(:find_matching_expectation, :render, options)
expect_render_mock_proxy.render(options)
if render_proxy.send(:__mock_proxy).send(:find_matching_expectation, :render, options)
render_proxy.render(options)
else
unless expect_render_mock_proxy.send(:__mock_proxy).send(:find_matching_method_stub, :render, options)
unless render_proxy.send(:__mock_proxy).send(:find_matching_method_stub, :render, options)
orig_render(options, old_local_assigns, &block)
end
end

14
vendor/plugins/rspec-rails/lib/spec/rails/interop/testcase.rb vendored Normal file
View file

@ -0,0 +1,14 @@
module Test
module Unit
class TestCase
# Edge rails (r8664) introduces class-wide setup & teardown callbacks for Test::Unit::TestCase.
# Make sure these still get run when running TestCases under rspec:
prepend_before(:each) do
run_callbacks :setup if respond_to?(:run_callbacks)
end
append_after(:each) do
run_callbacks :teardown if respond_to?(:run_callbacks)
end
end
end
end

1
vendor/plugins/rspec-rails/lib/spec/rails/matchers.rb vendored
View file

@ -1,5 +1,6 @@
dir = File.dirname(__FILE__)
require 'spec/rails/matchers/assert_select'
require 'spec/rails/matchers/change'
require 'spec/rails/matchers/have_text'
require 'spec/rails/matchers/include_text'
require 'spec/rails/matchers/redirect_to'

1
vendor/plugins/rspec-rails/lib/spec/rails/matchers/assert_select.rb vendored
View file

@ -16,6 +16,7 @@ module Spec # :nodoc:
def matches?(response_or_text, &block)
if ActionController::TestResponse === response_or_text and
response_or_text.headers.key?('Content-Type') and
!response_or_text.headers['Content-Type'].blank? and
response_or_text.headers['Content-Type'].to_sym == :xml
@args.unshift(HTML::Document.new(response_or_text.body, false, true).root)
elsif String === response_or_text

11
vendor/plugins/rspec-rails/lib/spec/rails/matchers/change.rb vendored Normal file
View file

@ -0,0 +1,11 @@
module Spec
module Matchers
class Change
def evaluate_value_proc_with_ensured_evaluation_of_proxy
value = evaluate_value_proc_without_ensured_evaluation_of_proxy
ActiveRecord::Associations::AssociationProxy === value ? value.dup : value
end
alias_method_chain :evaluate_value_proc, :ensured_evaluation_of_proxy
end
end
end

32
vendor/plugins/rspec-rails/lib/spec/rails/matchers/render_template.rb vendored
View file

@ -10,10 +10,18 @@ module Spec
end
def matches?(response)
@actual = response.rendered_file
full_path(@actual) == full_path(@expected)
if response.respond_to?(:rendered_file)
@actual = response.rendered_file
else
@actual = response.rendered_template.to_s
end
return false if @actual.blank?
given_controller_path, given_file = path_and_file(@actual)
expected_controller_path, expected_file = path_and_file(@expected)
given_controller_path == expected_controller_path && given_file.match(expected_file)
end
def failure_message
"expected #{@expected.inspect}, got #{@actual.inspect}"
end
@ -27,9 +35,21 @@ module Spec
end
private
def full_path(path)
return nil if path.nil?
path.include?('/') ? path : "#{@controller.class.to_s.underscore.gsub('_controller','')}/#{path}"
def path_and_file(path)
parts = path.split('/')
file = parts.pop
controller = parts.empty? ? current_controller_path : parts.join('/')
return controller, file
end
def controller_path_from(path)
parts = path.split('/')
parts.pop
parts.join('/')
end
def current_controller_path
@controller.class.to_s.underscore.gsub(/_controller$/,'')
end
end

55
vendor/plugins/rspec-rails/lib/spec/rails/mocks.rb vendored
View file

@ -9,15 +9,21 @@ module Spec
# methods stubbed out. Additional methods may be easily stubbed (via
# add_stubs) if +stubs+ is passed.
def mock_model(model_class, options_and_stubs = {})
id = next_id
options_and_stubs.reverse_merge!({
id = options_and_stubs[:id] || next_id
options_and_stubs = options_and_stubs.reverse_merge({
:id => id,
:to_param => id.to_s,
:new_record? => false,
:errors => stub("errors", :count => 0)
})
m = mock("#{model_class.name}_#{options_and_stubs[:id]}", options_and_stubs)
m = mock("#{model_class.name}_#{id}", options_and_stubs)
m.send(:__mock_proxy).instance_eval <<-CODE
def @target.as_new_record
self.stub!(:id).and_return nil
self.stub!(:to_param).and_return nil
self.stub!(:new_record?).and_return true
self
end
def @target.is_a?(other)
#{model_class}.ancestors.include?(other)
end
@ -52,24 +58,33 @@ module Spec
# stub_model(Model)
# stub_model(Model).as_new_record
# stub_model(Model, hash_of_stubs)
# stub_model(Model, instance_variable_name, hash_of_stubs)
#
# Creates an instance of +Model+ that is prohibited from accessing the
# database. For each key in +hash_of_stubs+, if the model has a
# matching attribute (determined by asking it, which it answers based
# on schema.rb) are simply assigned the submitted values. If the model
# does not have a matching attribute, the key/value pair is assigned
# as a stub return value using RSpec's mocking/stubbing framework.
# database*. For each key in +hash_of_stubs+, if the model has a
# matching attribute (determined by asking it) are simply assigned the
# submitted values. If the model does not have a matching attribute, the
# key/value pair is assigned as a stub return value using RSpec's
# mocking/stubbing framework.
#
# new_record? is overridden to return the result of id.nil? This means
# that by default new_record? will return false. If you want the
# object to behave as a new record, sending it +as_new_record+ will
# <tt>new_record?</tt> is overridden to return the result of id.nil?
# This means that by default new_record? will return false. If you want
# the object to behave as a new record, sending it +as_new_record+ will
# set the id to nil. You can also explicitly set :id => nil, in which
# case new_record? will return true, but using +as_new_record+ makes
# the example a bit more descriptive.
# case new_record? will return true, but using +as_new_record+ makes the
# example a bit more descriptive.
#
# While you can use stub_model in any example (model, view,
# controller, helper), it is especially useful in view examples,
# which are inherently more state-based than interaction-based.
# While you can use stub_model in any example (model, view, controller,
# helper), it is especially useful in view examples, which are
# inherently more state-based than interaction-based.
#
# == Database Independence
#
# +stub_model+ does not make your examples entirely
# database-independent. It does not stop the model class itself from
# loading up its columns from the database. It just prevents data access
# from the object itself. To completely decouple from the database, take
# a look at libraries like unit_record or NullDB.
#
# == Examples
#
@ -77,9 +92,9 @@ module Spec
# stub_model(Person).as_new_record
# stub_model(Person, :id => 37)
# stub_model(Person) do |person|
# model.first_name = "David"
# person.first_name = "David"
# end
def stub_model(model_class, stubs = {})
def stub_model(model_class, stubs={})
stubs = {:id => next_id}.merge(stubs)
returning model_class.new do |model|
model.id = stubs.delete(:id)
@ -99,7 +114,7 @@ module Spec
# - object.stub!(:method => return_value, :method2 => return_value2, :etc => etc)
#++
# Stubs methods on +object+ (if +object+ is a symbol or string a new mock
# with that name will be created). +stubs+ is a Hash of <tt>method=>value</tt>
# with that name will be created). +stubs+ is a Hash of +method=>value+
def add_stubs(object, stubs = {}) #:nodoc:
m = [String, Symbol].index(object.class) ? mock(object.to_s) : object
stubs.each {|k,v| m.stub!(k).and_return(v)}
@ -114,4 +129,4 @@ module Spec
end
end
end
end

14
vendor/plugins/rspec-rails/lib/spec/rails/story_adapter.rb vendored
View file

@ -40,15 +40,23 @@ class ActiveRecordSafetyListener
include Singleton
def scenario_started(*args)
if defined?(ActiveRecord::Base)
ActiveRecord::Base.send :increment_open_transactions unless Rails::VERSION::STRING == "1.1.6"
ActiveRecord::Base.connection.begin_db_transaction
if ActiveRecord::Base.connection.respond_to?(:increment_open_transactions)
ActiveRecord::Base.connection.increment_open_transactions
else
ActiveRecord::Base.send :increment_open_transactions
end
end
ActiveRecord::Base.connection.begin_db_transaction
end
def scenario_succeeded(*args)
if defined?(ActiveRecord::Base)
ActiveRecord::Base.connection.rollback_db_transaction
ActiveRecord::Base.send :decrement_open_transactions unless Rails::VERSION::STRING == "1.1.6"
if ActiveRecord::Base.connection.respond_to?(:decrement_open_transactions)
ActiveRecord::Base.connection.decrement_open_transactions
else
ActiveRecord::Base.send :decrement_open_transactions
end
end
end
alias :scenario_pending :scenario_succeeded

28
vendor/plugins/rspec-rails/lib/spec/rails/version.rb vendored
View file

@ -1,23 +1,15 @@
module Spec
module Rails
module VERSION #:nodoc:
BUILD_TIME_UTC = 20080615141040
unless defined? MAJOR
MAJOR = 1
MINOR = 1
TINY = 8
STRING = [MAJOR, MINOR, TINY].join('.')
SUMMARY = "rspec-rails #{STRING}"
end
end
end
end
# Verify that the plugin has the same revision as RSpec
if Spec::Rails::VERSION::BUILD_TIME_UTC != Spec::VERSION::BUILD_TIME_UTC
raise <<-EOF
############################################################################
Your RSpec on Rails plugin is incompatible with your installed RSpec.
RSpec : #{Spec::VERSION::BUILD_TIME_UTC}
RSpec on Rails : #{Spec::Rails::VERSION::BUILD_TIME_UTC}
Make sure your RSpec on Rails plugin is compatible with your RSpec gem.
See http://rspec.rubyforge.org/documentation/rails/install.html for details.
############################################################################
EOF
end
end

35
vendor/plugins/rspec-rails/rspec-rails.gemspec vendored Normal file
View file

File diff suppressed because one or more lines are too long

2
vendor/plugins/rspec-rails/spec/rails/autotest/mappings_spec.rb vendored
View file

@ -1,6 +1,6 @@
require File.dirname(__FILE__) + '/../../spec_helper'
require File.join(File.dirname(__FILE__), *%w[.. .. .. lib autotest rails_rspec])
require File.join(File.dirname(__FILE__), *%w[.. .. .. .. rspec spec autotest_matchers])
require File.join(File.dirname(__FILE__), *%w[.. .. .. .. rspec spec autotest autotest_matchers])
describe Autotest::RailsRspec, "file mapping" do
before(:each) do

8
vendor/plugins/rspec-rails/spec/rails/autotest/rails_rspec_spec.rb vendored
View file

@ -1,8 +0,0 @@
require File.dirname(__FILE__) + '/../../spec_helper'
require File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "autotest", "rails_rspec")
describe Autotest::RailsRspec do
it "should provide the correct spec_command" do
Autotest::RailsRspec.new.spec_command.should == "script/spec"
end
end

Some files were not shown because too many files have changed in this diff Show more