vibes-bj 1.2.1

data/spec/rails_root/vendor/rails/actionpack/RUNNING_UNIT_TESTS

@@ -0,0 +1,24 @@
+== Running with Rake
+
+The easiest way to run the unit tests is through Rake. The default task runs
+the entire test suite for all classes. For more information, checkout the 
+full array of rake tasks with "rake -T"
+
+Rake can be found at http://rake.rubyforge.org
+
+== Running by hand
+
+If you only want to run a single test suite, or don't want to bother with Rake,
+you can do so with something like:
+
+   ruby controller/base_tests.rb
+
+== Dependency on ActiveRecord and database setup
+
+Test cases in the test/controller/active_record/ directory depend on having
+activerecord and sqlite installed. If ActiveRecord is not in 
+actionpack/../activerecord directory, or the sqlite rubygem is not installed,
+these tests are skipped.
+
+Other tests are runnable from a fresh copy of actionpack without any configuration.
+

data/spec/rails_root/vendor/rails/actionpack/Rakefile

@@ -0,0 +1,154 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+require File.join(File.dirname(__FILE__), 'lib', 'action_pack', 'version')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'actionpack'
+PKG_VERSION   = ActionPack::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "actionpack"
+RUBY_FORGE_USER    = "webster132"
+
+desc "Default Task"
+task :default => [ :test ]
+
+# Run the unit tests
+
+desc "Run all unit tests"
+task :test => [:test_action_pack, :test_active_record_integration]
+
+Rake::TestTask.new(:test_action_pack) { |t|
+  t.libs << "test"
+# make sure we include the tests in alphabetical order as on some systems
+# this will not happen automatically and the tests (as a whole) will error
+  t.test_files=Dir.glob( "test/[cft]*/**/*_test.rb" ).sort
+#  t.pattern = 'test/*/*_test.rb'
+  t.verbose = true
+}
+
+desc 'ActiveRecord Integration Tests'
+Rake::TestTask.new(:test_active_record_integration) do |t|
+  t.libs << "test"
+  t.test_files = Dir.glob("test/activerecord/*_test.rb")
+  t.verbose = true
+end
+
+
+# Genereate the RDoc documentation
+
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Action Pack -- On rails from request to response"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  if ENV['DOC_FILES'] 
+    rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
+  else
+    rdoc.rdoc_files.include('README', 'RUNNING_UNIT_TESTS', 'CHANGELOG')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
+}
+
+# Create compressed packages
+dist_dirs = [ "lib", "test" ]
+
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "Web-flow and rendering framework putting the VC in MVC."
+  s.description = %q{Eases web-request routing, handling, and response as a half-way front, half-way page controller. Implemented with specific emphasis on enabling easy unit/integration testing that doesn't require a browser.} #'
+
+  s.author = "David Heinemeier Hansson"
+  s.email = "david@loudthinking.com"
+  s.rubyforge_project = "actionpack"
+  s.homepage = "http://www.rubyonrails.org"
+
+  s.has_rdoc = true
+  s.requirements << 'none'
+
+  s.add_dependency('activesupport', '= 2.1.0' + PKG_BUILD)
+
+  s.require_path = 'lib'
+  s.autorequire = 'action_controller'
+
+  s.files = [ "Rakefile", "install.rb", "README", "RUNNING_UNIT_TESTS", "CHANGELOG", "MIT-LICENSE" ]
+  dist_dirs.each do |dir|
+    s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+  end
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+task :lines do
+  lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+
+  for file_name in FileList["lib/**/*.rb"]
+    next if file_name =~ /vendor/
+    f = File.open(file_name)
+
+    while line = f.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+    puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
+    
+    total_lines     += lines
+    total_codelines += codelines
+    
+    lines, codelines = 0, 0
+  end
+
+  puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+end
+
+# Publishing ------------------------------------------------------
+
+task :update_scriptaculous do
+  for js in %w( controls dragdrop effects )
+    system("svn export --force http://dev.rubyonrails.org/svn/rails/spinoffs/scriptaculous/src/#{js}.js #{File.dirname(__FILE__)}/lib/action_view/helpers/javascripts/#{js}.js")
+  end
+end
+
+desc "Updates actionpack to the latest version of the javascript spinoffs"
+task :update_js => [ :update_scriptaculous ]
+
+# Publishing ------------------------------------------------------
+
+desc "Publish the API documentation"
+task :pgem => [:package] do 
+  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh davidhh@wrath.rubyonrails.org './gemupdate.sh'`
+end
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do 
+  Rake::SshDirPublisher.new("davidhh@wrath.rubyonrails.org", "public_html/ap", "doc").upload
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  require 'rubyforge'
+  require 'rake/contrib/rubyforgepublisher'
+
+  packages = %w( gem tgz zip ).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
+
+  rubyforge = RubyForge.new
+  rubyforge.login
+  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
+end

data/spec/rails_root/vendor/rails/actionpack/install.rb

@@ -0,0 +1,30 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+# this was adapted from rdoc's install.rb by way of Log4r
+
+$sitedir = CONFIG["sitelibdir"]
+unless $sitedir
+  version = CONFIG["MAJOR"] + "." + CONFIG["MINOR"]
+  $libdir = File.join(CONFIG["libdir"], "ruby", version)
+  $sitedir = $:.find {|x| x =~ /site_ruby/ }
+  if !$sitedir
+    $sitedir = File.join($libdir, "site_ruby")
+  elsif $sitedir !~ Regexp.quote(version)
+    $sitedir = File.join($sitedir, version)
+  end
+end
+
+# the actual gruntwork
+Dir.chdir("lib")
+
+Find.find("action_controller", "action_controller.rb", "action_view", "action_view.rb") { |f|
+  if f[-3..-1] == ".rb"
+    File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
+  else
+    File::makedirs(File.join($sitedir, *f.split(/\//)))
+  end
+}

data/spec/rails_root/vendor/rails/actionpack/lib/action_controller.rb

@@ -0,0 +1,79 @@
+#--
+# Copyright (c) 2004-2008 David Heinemeier Hansson
+#
+# 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.
+#++
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+unless defined?(ActiveSupport)
+  begin
+    $:.unshift "#{File.dirname(__FILE__)}/../../activesupport/lib"
+    require 'active_support'
+  rescue LoadError
+    require 'rubygems'
+    gem 'activesupport'
+  end
+end
+
+$:.unshift "#{File.dirname(__FILE__)}/action_controller/vendor/html-scanner"
+
+require 'action_controller/base'
+require 'action_controller/request'
+require 'action_controller/rescue'
+require 'action_controller/benchmarking'
+require 'action_controller/flash'
+require 'action_controller/filters'
+require 'action_controller/layout'
+require 'action_controller/mime_responds'
+require 'action_controller/helpers'
+require 'action_controller/cookies'
+require 'action_controller/cgi_process'
+require 'action_controller/caching'
+require 'action_controller/verification'
+require 'action_controller/streaming'
+require 'action_controller/session_management'
+require 'action_controller/http_authentication'
+require 'action_controller/components'
+require 'action_controller/record_identifier'
+require 'action_controller/request_forgery_protection'
+require 'action_controller/headers'
+
+require 'action_view'
+
+ActionController::Base.class_eval do
+  include ActionController::Flash
+  include ActionController::Filters
+  include ActionController::Layout
+  include ActionController::Benchmarking
+  include ActionController::Rescue
+  include ActionController::MimeResponds
+  include ActionController::Helpers
+  include ActionController::Cookies
+  include ActionController::Caching
+  include ActionController::Verification
+  include ActionController::Streaming
+  include ActionController::SessionManagement
+  include ActionController::HttpAuthentication::Basic::ControllerMethods
+  include ActionController::Components
+  include ActionController::RecordIdentifier
+  include ActionController::RequestForgeryProtection
+end

data/spec/rails_root/vendor/rails/actionpack/lib/action_controller/assertions.rb

@@ -0,0 +1,69 @@
+require 'test/unit/assertions'
+
+module ActionController #:nodoc:
+  # In addition to these specific assertions, you also have easy access to various collections that the regular test/unit assertions
+  # can be used against. These collections are:
+  #
+  # * assigns: Instance variables assigned in the action that are available for the view.
+  # * session: Objects being saved in the session.
+  # * flash: The flash objects currently in the session.
+  # * cookies: Cookies being sent to the user on this request.
+  #
+  # These collections can be used just like any other hash:
+  #
+  #   assert_not_nil assigns(:person) # makes sure that a @person instance variable was set
+  #   assert_equal "Dave", cookies[:name] # makes sure that a cookie called :name was set as "Dave"
+  #   assert flash.empty? # makes sure that there's nothing in the flash
+  #
+  # For historic reasons, the assigns hash uses string-based keys. So assigns[:person] won't work, but assigns["person"] will. To
+  # appease our yearning for symbols, though, an alternative accessor has been devised using a method call instead of index referencing.
+  # So assigns(:person) will work just like assigns["person"], but again, assigns[:person] will not work.
+  #
+  # On top of the collections, you have the complete url that a given action redirected to available in redirect_to_url.
+  #
+  # For redirects within the same controller, you can even call follow_redirect and the redirect will be followed, triggering another
+  # action call which can then be asserted against.
+  #
+  # == Manipulating the request collections
+  #
+  # The collections described above link to the response, so you can test if what the actions were expected to do happened. But
+  # sometimes you also want to manipulate these collections in the incoming request. This is really only relevant for sessions
+  # and cookies, though. For sessions, you just do:
+  #
+  #   @request.session[:key] = "value"
+  #
+  # For cookies, you need to manually create the cookie, like this:
+  #
+  #   @request.cookies["key"] = CGI::Cookie.new("key", "value")
+  #
+  # == Testing named routes
+  #
+  # If you're using named routes, they can be easily tested using the original named routes' methods straight in the test case.
+  # Example:
+  #
+  #  assert_redirected_to page_url(:title => 'foo')
+  module Assertions
+    def self.included(klass)
+      %w(response selector tag dom routing model).each do |kind|
+        require "action_controller/assertions/#{kind}_assertions"
+        klass.module_eval { include const_get("#{kind.camelize}Assertions") }
+      end
+    end
+
+    def clean_backtrace(&block)
+      yield
+    rescue Test::Unit::AssertionFailedError => error
+      framework_path = Regexp.new(File.expand_path("#{File.dirname(__FILE__)}/assertions"))
+      error.backtrace.reject! { |line| File.expand_path(line) =~ framework_path }
+      raise
+    end
+  end
+end
+
+module Test #:nodoc:
+  module Unit #:nodoc:
+    class TestCase #:nodoc:
+      include ActionController::Assertions
+    end
+  end
+end

data/spec/rails_root/vendor/rails/actionpack/lib/action_controller/assertions/dom_assertions.rb

@@ -0,0 +1,39 @@
+module ActionController
+  module Assertions
+    module DomAssertions
+      # Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
+      #
+      # ==== Examples
+      #
+      #   # assert that the referenced method generates the appropriate HTML string
+      #   assert_dom_equal '<a href="http://www.example.com">Apples</a>', link_to("Apples", "http://www.example.com")
+      #
+      def assert_dom_equal(expected, actual, message = "")
+        clean_backtrace do
+          expected_dom = HTML::Document.new(expected).root
+          actual_dom   = HTML::Document.new(actual).root
+          full_message = build_message(message, "<?> expected to be == to\n<?>.", expected_dom.to_s, actual_dom.to_s)
+
+          assert_block(full_message) { expected_dom == actual_dom }
+        end
+      end
+      
+      # The negated form of +assert_dom_equivalent+.
+      #
+      # ==== Examples
+      #
+      #   # assert that the referenced method does not generate the specified HTML string
+      #   assert_dom_not_equal '<a href="http://www.example.com">Apples</a>', link_to("Oranges", "http://www.example.com")
+      #
+      def assert_dom_not_equal(expected, actual, message = "")
+        clean_backtrace do
+          expected_dom = HTML::Document.new(expected).root
+          actual_dom   = HTML::Document.new(actual).root
+          full_message = build_message(message, "<?> expected to be != to\n<?>.", expected_dom.to_s, actual_dom.to_s)
+
+          assert_block(full_message) { expected_dom != actual_dom }
+        end
+      end
+    end
+  end
+end

data/spec/rails_root/vendor/rails/actionpack/lib/action_controller/assertions/model_assertions.rb

@@ -0,0 +1,20 @@
+module ActionController
+  module Assertions
+    module ModelAssertions
+      # Ensures that the passed record is valid by Active Record standards and
+      # returns any error messages if it is not.
+      #
+      # ==== Examples
+      #
+      #   # assert that a newly created record is valid
+      #   model = Model.new
+      #   assert_valid(model)
+      #
+      def assert_valid(record)
+        clean_backtrace do
+          assert record.valid?, record.errors.full_messages.join("\n")
+        end
+      end
+    end
+  end
+end

data/spec/rails_root/vendor/rails/actionpack/lib/action_controller/assertions/response_assertions.rb

@@ -0,0 +1,172 @@
+require 'rexml/document'
+require 'html/document'
+
+module ActionController
+  module Assertions
+    # A small suite of assertions that test responses from Rails applications.
+    module ResponseAssertions
+      # Asserts that the response is one of the following types:
+      #
+      # * <tt>:success</tt>   - Status code was 200
+      # * <tt>:redirect</tt>  - Status code was in the 300-399 range
+      # * <tt>:missing</tt>   - Status code was 404
+      # * <tt>:error</tt>     - Status code was in the 500-599 range
+      #
+      # You can also pass an explicit status number like assert_response(501)
+      # or its symbolic equivalent assert_response(:not_implemented).
+      # See ActionController::StatusCodes for a full list.
+      #
+      # ==== Examples
+      #
+      #   # assert that the response was a redirection
+      #   assert_response :redirect 
+      #
+      #   # assert that the response code was status code 401 (unauthorized)
+      #   assert_response 401
+      #
+      def assert_response(type, message = nil)
+        clean_backtrace do
+          if [ :success, :missing, :redirect, :error ].include?(type) && @response.send("#{type}?")
+            assert_block("") { true } # to count the assertion
+          elsif type.is_a?(Fixnum) && @response.response_code == type
+            assert_block("") { true } # to count the assertion
+          elsif type.is_a?(Symbol) && @response.response_code == ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
+            assert_block("") { true } # to count the assertion
+          else
+            if @response.error?
+              exception = @response.template.instance_variable_get(:@exception)
+              exception_message = exception && exception.message
+              assert_block(build_message(message, "Expected response to be a <?>, but was <?>\n<?>", type, @response.response_code, exception_message.to_s)) { false }
+            else
+              assert_block(build_message(message, "Expected response to be a <?>, but was <?>", type, @response.response_code)) { false }
+            end
+          end
+        end
+      end
+
+      # Assert that the redirection options passed in match those of the redirect called in the latest action. 
+      # This match can be partial, such that assert_redirected_to(:controller => "weblog") will also
+      # match the redirection of redirect_to(:controller => "weblog", :action => "show") and so on.
+      #
+      # ==== Examples
+      #
+      #   # assert that the redirection was to the "index" action on the WeblogController
+      #   assert_redirected_to :controller => "weblog", :action => "index"
+      #
+      #   # assert that the redirection was to the named route login_url
+      #   assert_redirected_to login_url
+      #
+      def assert_redirected_to(options = {}, message=nil)
+        clean_backtrace do
+          assert_response(:redirect, message)
+          return true if options == @response.redirected_to
+          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+
+          begin
+            url  = {}
+            original = { :expected => options, :actual => @response.redirected_to.is_a?(Symbol) ? @response.redirected_to : @response.redirected_to.dup }
+            original.each do |key, value|
+              if value.is_a?(Symbol)
+                value = @controller.respond_to?(value, true) ? @controller.send(value) : @controller.send("hash_for_#{value}_url")
+              end
+
+              unless value.is_a?(Hash)
+                request = case value
+                  when NilClass    then nil
+                  when /^\w+:\/\// then recognized_request_for(%r{^(\w+://.*?(/|$|\?))(.*)$} =~ value ? $3 : nil)
+                  else                  recognized_request_for(value)
+                end
+                value = request.path_parameters if request
+              end
+
+              if value.is_a?(Hash) # stringify 2 levels of hash keys
+                if name = value.delete(:use_route)
+                  route = ActionController::Routing::Routes.named_routes[name]
+                  value.update(route.parameter_shell)
+                end
+
+                value.stringify_keys!
+                value.values.select { |v| v.is_a?(Hash) }.collect { |v| v.stringify_keys! }
+                if key == :expected && value['controller'] == @controller.controller_name && original[:actual].is_a?(Hash)
+                  original[:actual].stringify_keys!
+                  value.delete('controller') if original[:actual]['controller'].nil? || original[:actual]['controller'] == value['controller']
+                end
+              end
+
+              if value.respond_to?(:[]) && value['controller']
+                value['controller'] = value['controller'].to_s
+                if key == :actual && value['controller'].first != '/' && !value['controller'].include?('/')
+                  new_controller_path = ActionController::Routing.controller_relative_to(value['controller'], @controller.class.controller_path)
+                  value['controller'] = new_controller_path if value['controller'] != new_controller_path && ActionController::Routing.possible_controllers.include?(new_controller_path)
+                end
+                value['controller'] = value['controller'][1..-1] if value['controller'].first == '/' # strip leading hash
+              end
+              url[key] = value
+            end
+
+            @response_diff = url[:actual].diff(url[:expected]) if url[:actual]
+            msg = build_message(message, "expected a redirect to <?>, found one to <?>, a difference of <?> ", url[:expected], url[:actual], @response_diff)
+
+            assert_block(msg) do
+              url[:expected].keys.all? do |k|
+                if k == :controller then url[:expected][k] == ActionController::Routing.controller_relative_to(url[:actual][k], @controller.class.controller_path)
+                else parameterize(url[:expected][k]) == parameterize(url[:actual][k])
+                end
+              end
+            end
+          rescue ActionController::RoutingError # routing failed us, so match the strings only.
+            msg = build_message(message, "expected a redirect to <?>, found one to <?>", options, @response.redirect_url)
+            url_regexp = %r{^(\w+://.*?(/|$|\?))(.*)$}
+            eurl, epath, url, path = [options, @response.redirect_url].collect do |url|
+              u, p = (url_regexp =~ url) ? [$1, $3] : [nil, url]
+              [u, (p.first == '/') ? p : '/' + p]
+            end.flatten
+
+            assert_equal(eurl, url, msg) if eurl && url
+            assert_equal(epath, path, msg) if epath && path
+          end
+        end
+      end
+
+      # Asserts that the request was rendered with the appropriate template file.
+      #
+      # ==== Examples
+      #
+      #   # assert that the "new" view template was rendered
+      #   assert_template "new"
+      #
+      def assert_template(expected = nil, message=nil)
+        clean_backtrace do
+          rendered = expected ? @response.rendered_file(!expected.include?('/')) : @response.rendered_file
+          msg = build_message(message, "expecting <?> but rendering with <?>", expected, rendered)
+          assert_block(msg) do
+            if expected.nil?
+              !@response.rendered_with_file?
+            else
+              expected == rendered
+            end
+          end
+        end
+      end
+
+      private
+        # Recognizes the route for a given path.
+        def recognized_request_for(path, request_method = nil)
+          path = "/#{path}" unless path.first == '/'
+
+          # Assume given controller
+          request = ActionController::TestRequest.new({}, {}, nil)
+          request.env["REQUEST_METHOD"] = request_method.to_s.upcase if request_method
+          request.path   = path
+
+          ActionController::Routing::Routes.recognize(request)
+          request
+        end
+
+        # Proxy to to_param if the object will respond to it.
+        def parameterize(value)
+          value.respond_to?(:to_param) ? value.to_param : value
+        end
+    end
+  end
+end