RubyGems - radiant - Versions diffs - 0.5.2 → 0.6.0 - Mend

radiant 0.5.2 → 0.6.0

Potentially problematic release.

This version of radiant might be problematic. Click here for more details.

Files changed (1442) hide show

data/vendor/rails/actionpack/examples/debate/index.rhtml ADDED

@@ -0,0 +1,14 @@
+<html>
+<body>
+<h1>Topics</h1>
+<%= link_to "New topic", :action => "new_topic" %>
+<ul>
+<% for topic in @topics %>
+  <li><%= link_to "#{topic.title} (#{topic.replies.length} replies)", :action => "topic", :path_params => { "id" => topic.id } %></li>
+<% end %>
+</ul>
+</body>
+</html>

data/vendor/rails/actionpack/examples/debate/new_topic.rhtml ADDED

@@ -0,0 +1,22 @@
+<html>
+<body>
+<h1>New topic</h1>
+<form action="<%= url_for(:action => "create_topic") %>" method="post">
+  <p>
+    Title:<br>
+    <input type="text" name="topic[title]">
+  </p>
+  <p>
+    Body:<br>
+    <textarea name="topic[body]" style="width: 200px; height: 200px"></textarea>
+  </p>
+  <p>
+    <input type="submit" value="Create topic">
+  </p>
+</form>
+</body>
+</html>

data/vendor/rails/actionpack/examples/debate/topic.rhtml ADDED

@@ -0,0 +1,32 @@
+<html>
+<body>
+<h1><%= @topic.title %></h1>
+<p><%= @topic.body %></p>
+<%= link_to "Back to topics", :action => "index" %>
+<% unless @topic.replies.empty? %>
+  <h2>Replies</h2>
+  <ol>
+  <% for reply in @topic.replies %>
+    <li><%= reply.body %></li>
+  <% end %>
+  </ol>
+<% end %>
+<h2>Reply to this topic</h2>
+<form action="<%= url_for(:action => "create_reply") %>" method="post">
+  <input type="hidden" name="reply[topic_id]" value="<%= @topic.id %>">
+  <p>
+    <textarea name="reply[body]" style="width: 200px; height: 200px"></textarea>
+  </p>
+  <p>
+    <input type="submit" value="Create reply">
+  </p>
+</form>
+</body>
+</html>

data/vendor/rails/actionpack/examples/debate_controller.cgi ADDED

@@ -0,0 +1,57 @@
+#!/usr/local/bin/ruby
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+require "action_controller"
+Topic = Struct.new("Topic", :id, :title, :body, :replies)
+Reply = Struct.new("Reply", :body)
+class DebateService
+  attr_reader :topics
+  def initialize()         @topics = [] end
+  def create_topic(data)   topics.unshift(Topic.new(next_topic_id, data["title"], data["body"], [])) end
+  def create_reply(data)   find_topic(data["topic_id"]).replies << Reply.new(data["body"]) end
+  def find_topic(topic_id) topics.select { |topic| topic.id == topic_id.to_i }.first end
+  def next_topic_id()      topics.first.id + 1 end
+end
+class DebateController < ActionController::Base
+  before_filter :initialize_session_storage
+  def index
+    @topics = @debate.topics
+  end
+  def topic
+    @topic = @debate.find_topic(params[:id])
+  end
+  # def new_topic() end <-- This is not needed as the template doesn't require any assigns
+  def create_topic
+    @debate.create_topic(params[:topic])
+    redirect_to :action => "index"
+  end
+  def create_reply
+    @debate.create_reply(params[:reply])
+    redirect_to :action => "topic", :path_params => { "id" => params[:reply][:topic_id] }
+  end
+  private
+    def initialize_session_storage
+      @session["debate"] = DebateService.new if @session["debate"].nil?
+      @debate = @session["debate"]
+    end
+end
+ActionController::Base.template_root = File.dirname(__FILE__)
+# ActionController::Base.logger = Logger.new("debug.log") # Remove first comment to turn on logging in current dir
+begin
+  DebateController.process_cgi(CGI.new) if $0 == __FILE__
+rescue => e
+  CGI.new.out { "#{e.class}: #{e.message}" }
+end

data/vendor/rails/actionpack/install.rb ADDED

@@ -0,0 +1,30 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+include Config
+# this was adapted from rdoc's install.rb by ways 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 acual 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/vendor/rails/actionpack/lib/action_controller.rb ADDED

@@ -0,0 +1,83 @@
+#--
+# Copyright (c) 2004-2006 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
+require 'action_controller/base'
+require 'action_controller/deprecated_redirects'
+require 'action_controller/request'
+require 'action_controller/deprecated_request_methods'
+require 'action_controller/rescue'
+require 'action_controller/benchmarking'
+require 'action_controller/flash'
+require 'action_controller/filters'
+require 'action_controller/layout'
+require 'action_controller/deprecated_dependencies'
+require 'action_controller/mime_responds'
+require 'action_controller/pagination'
+require 'action_controller/scaffolding'
+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/components'
+require 'action_controller/macros/auto_complete'
+require 'action_controller/macros/in_place_editing'
+require 'action_view'
+ActionController::Base.template_class = ActionView::Base
+ActionController::Base.class_eval do
+  include ActionController::Flash
+  include ActionController::Filters
+  include ActionController::Layout
+  include ActionController::Benchmarking
+  include ActionController::Rescue
+  include ActionController::Dependencies
+  include ActionController::MimeResponds
+  include ActionController::Pagination
+  include ActionController::Scaffolding
+  include ActionController::Helpers
+  include ActionController::Cookies
+  include ActionController::Caching
+  include ActionController::Verification
+  include ActionController::Streaming
+  include ActionController::SessionManagement
+  include ActionController::Components
+  include ActionController::Macros::AutoComplete
+  include ActionController::Macros::InPlaceEditing
+end

data/vendor/rails/actionpack/lib/action_controller/assertions.rb ADDED

@@ -0,0 +1,82 @@
+require 'test/unit'
+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 deviced 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)
+      klass.class_eval do
+        include ActionController::Assertions::ResponseAssertions
+        include ActionController::Assertions::SelectorAssertions
+        include ActionController::Assertions::RoutingAssertions
+        include ActionController::Assertions::TagAssertions
+        include ActionController::Assertions::DomAssertions
+        include ActionController::Assertions::ModelAssertions
+        include ActionController::Assertions::DeprecatedAssertions
+      end
+    end
+    def clean_backtrace(&block)
+      yield
+    rescue Test::Unit::AssertionFailedError => e
+      path = File.expand_path(__FILE__)
+      raise Test::Unit::AssertionFailedError, e.message, e.backtrace.reject { |line| File.expand_path(line) =~ /#{path}/ }
+    end
+  end
+end
+require File.dirname(__FILE__) + '/assertions/response_assertions'
+require File.dirname(__FILE__) + '/assertions/selector_assertions'
+require File.dirname(__FILE__) + '/assertions/tag_assertions'
+require File.dirname(__FILE__) + '/assertions/dom_assertions'
+require File.dirname(__FILE__) + '/assertions/routing_assertions'
+require File.dirname(__FILE__) + '/assertions/model_assertions'
+require File.dirname(__FILE__) + '/assertions/deprecated_assertions'
+module Test #:nodoc:
+  module Unit #:nodoc:
+    class TestCase #:nodoc:
+      include ActionController::Assertions
+    end
+  end
+end

data/vendor/rails/actionpack/lib/action_controller/assertions/deprecated_assertions.rb ADDED

@@ -0,0 +1,228 @@
+require 'rexml/document'
+module ActionController #:nodoc:
+  module Assertions #:nodoc:
+    module DeprecatedAssertions #:nodoc:
+      def assert_success(message=nil) #:nodoc:
+        assert_response(:success, message)
+      end
+      deprecate :assert_success => "use assert_response(:success)"
+      def assert_redirect(message=nil) #:nodoc:
+        assert_response(:redirect, message)
+      end
+      deprecate :assert_redirect => "use assert_response(:redirect)"
+      def assert_rendered_file(expected=nil, message=nil) #:nodoc:
+        assert_template(expected, message)
+      end
+      deprecate :assert_rendered_file => :assert_template
+      # ensure that the session has an object with the specified name
+      def assert_session_has(key=nil, message=nil) #:nodoc:
+        msg = build_message(message, "<?> is not in the session <?>", key, @response.session)
+        assert_block(msg) { @response.has_session_object?(key) }
+      end
+      deprecate :assert_session_has => "use assert(@response.has_session_object?(key))"
+      # ensure that the session has no object with the specified name
+      def assert_session_has_no(key=nil, message=nil) #:nodoc:
+        msg = build_message(message, "<?> is in the session <?>", key, @response.session)
+        assert_block(msg) { !@response.has_session_object?(key) }
+      end
+      deprecate :assert_session_has_no => "use assert(!@response.has_session_object?(key))"
+      def assert_session_equal(expected = nil, key = nil, message = nil) #:nodoc:
+        msg = build_message(message, "<?> expected in session['?'] but was <?>", expected, key, @response.session[key])
+        assert_block(msg) { expected == @response.session[key] }
+      end
+      deprecate :assert_session_equal => "use assert_equal(expected, @response[key])"
+      # -- cookie assertions ---------------------------------------------------
+      def assert_no_cookie(key = nil, message = nil) #:nodoc:
+        actual = @response.cookies[key]
+        msg = build_message(message, "<?> not expected in cookies['?']", actual, key)
+        assert_block(msg) { actual.nil? or actual.empty? }
+      end
+      deprecate :assert_no_cookie => "use assert(!@response.cookies.key?(key))"
+      def assert_cookie_equal(expected = nil, key = nil, message = nil) #:nodoc:
+        actual = @response.cookies[key]
+        actual = actual.first if actual
+        msg = build_message(message, "<?> expected in cookies['?'] but was <?>", expected, key, actual)
+        assert_block(msg) { expected == actual }
+      end
+      deprecate :assert_cookie_equal => "use assert(@response.cookies.key?(key))"
+      # -- flash assertions ---------------------------------------------------
+      # ensure that the flash has an object with the specified name
+      def assert_flash_has(key=nil, message=nil) #:nodoc:
+        msg = build_message(message, "<?> is not in the flash <?>", key, @response.flash)
+        assert_block(msg) { @response.has_flash_object?(key) }
+      end
+      deprecate :assert_flash_has => "use assert(@response.has_flash_object?(key))"
+      # ensure that the flash has no object with the specified name
+      def assert_flash_has_no(key=nil, message=nil) #:nodoc:
+        msg = build_message(message, "<?> is in the flash <?>", key, @response.flash)
+        assert_block(msg) { !@response.has_flash_object?(key) }
+      end
+      deprecate :assert_flash_has_no => "use assert(!@response.has_flash_object?(key))"
+      # ensure the flash exists
+      def assert_flash_exists(message=nil) #:nodoc:
+        msg = build_message(message, "the flash does not exist <?>", @response.session['flash'] )
+        assert_block(msg) { @response.has_flash? }
+      end
+      deprecate :assert_flash_exists => "use assert(@response.has_flash?)"
+      # ensure the flash does not exist
+      def assert_flash_not_exists(message=nil) #:nodoc:
+        msg = build_message(message, "the flash exists <?>", @response.flash)
+        assert_block(msg) { !@response.has_flash? }
+      end
+      deprecate :assert_flash_not_exists => "use assert(!@response.has_flash?)"
+      # ensure the flash is empty but existent
+      def assert_flash_empty(message=nil) #:nodoc:
+        msg = build_message(message, "the flash is not empty <?>", @response.flash)
+        assert_block(msg) { !@response.has_flash_with_contents? }
+      end
+      deprecate :assert_flash_empty => "use assert(!@response.has_flash_with_contents?)"
+      # ensure the flash is not empty
+      def assert_flash_not_empty(message=nil) #:nodoc:
+        msg = build_message(message, "the flash is empty")
+        assert_block(msg) { @response.has_flash_with_contents? }
+      end
+      deprecate :assert_flash_not_empty => "use assert(@response.has_flash_with_contents?)"
+      def assert_flash_equal(expected = nil, key = nil, message = nil) #:nodoc:
+        msg = build_message(message, "<?> expected in flash['?'] but was <?>", expected, key, @response.flash[key])
+        assert_block(msg) { expected == @response.flash[key] }
+      end
+      deprecate :assert_flash_equal => "use assert_equal(expected, @response.flash[key])"
+      # ensure our redirection url is an exact match
+      def assert_redirect_url(url=nil, message=nil) #:nodoc:
+        assert_redirect(message)
+        msg = build_message(message, "<?> is not the redirected location <?>", url, @response.redirect_url)
+        assert_block(msg) { @response.redirect_url == url }
+      end
+      deprecate :assert_redirect_url => "use assert_equal(url, @response.redirect_url)"
+      # ensure our redirection url matches a pattern
+      def assert_redirect_url_match(pattern=nil, message=nil) #:nodoc:
+        assert_redirect(message)
+        msg = build_message(message, "<?> was not found in the location: <?>", pattern, @response.redirect_url)
+        assert_block(msg) { @response.redirect_url_match?(pattern) }
+      end
+      deprecate :assert_redirect_url_match => "use assert(@response.redirect_url_match?(pattern))"
+      # -- template assertions ------------------------------------------------
+      # ensure that a template object with the given name exists
+      def assert_template_has(key=nil, message=nil) #:nodoc:
+        msg = build_message(message, "<?> is not a template object", key )
+        assert_block(msg) { @response.has_template_object?(key) }
+      end
+      deprecate :assert_template_has => "use assert(@response.has_template_object?(key))"
+      # ensure that a template object with the given name does not exist
+      def assert_template_has_no(key=nil,message=nil) #:nodoc:
+        msg = build_message(message, "<?> is a template object <?>", key, @response.template_objects[key])
+        assert_block(msg) { !@response.has_template_object?(key) }
+      end
+      deprecate :assert_template_has_no => "use assert(!@response.has_template_object?(key))"
+      # ensures that the object assigned to the template on +key+ is equal to +expected+ object.
+      def assert_template_equal(expected = nil, key = nil, message = nil) #:nodoc:
+        msg = build_message(message, "<?> expected in assigns['?'] but was <?>", expected, key, @response.template.assigns[key.to_s])
+        assert_block(msg) { expected == @response.template.assigns[key.to_s] }
+      end
+      alias_method :assert_assigned_equal, :assert_template_equal
+      deprecate :assert_assigned_equal => "use assert_equal(expected, @response.template.assigns[key.to_s])"
+      deprecate :assert_template_equal => "use assert_equal(expected, @response.template.assigns[key.to_s])"
+      # Asserts that the template returns the +expected+ string or array based on the XPath +expression+.
+      # This will only work if the template rendered a valid XML document.
+      def assert_template_xpath_match(expression=nil, expected=nil, message=nil) #:nodoc:
+        xml, matches = REXML::Document.new(@response.body), []
+        xml.elements.each(expression) { |e| matches << e.text }
+        if matches.empty? then
+          msg = build_message(message, "<?> not found in document", expression)
+          flunk(msg)
+          return
+        elsif matches.length < 2 then
+          matches = matches.first
+        end
+        msg = build_message(message, "<?> found <?>, not <?>", expression, matches, expected)
+        assert_block(msg) { matches == expected }
+      end
+      deprecate :assert_template_xpath_match => "you should use assert_tag, instead"
+      # Assert the template object with the given name is an Active Record descendant and is valid.
+      def assert_valid_record(key = nil, message = nil) #:nodoc:
+        record = find_record_in_template(key)
+        msg = build_message(message, "Active Record is invalid <?>)", record.errors.full_messages)
+        assert_block(msg) { record.valid? }
+      end
+      deprecate :assert_valid_record => "use assert(assigns(key).valid?)"
+      # Assert the template object with the given name is an Active Record descendant and is invalid.
+      def assert_invalid_record(key = nil, message = nil) #:nodoc:
+        record = find_record_in_template(key)
+        msg = build_message(message, "Active Record is valid)")
+        assert_block(msg) { !record.valid? }
+      end
+      deprecate :assert_invalid_record => "use assert(!assigns(key).valid?)"
+      # Assert the template object with the given name is an Active Record descendant and the specified column(s) are valid.
+      def assert_valid_column_on_record(key = nil, columns = "", message = nil) #:nodoc:
+        record = find_record_in_template(key)
+        record.send(:validate)
+        cols = glue_columns(columns)
+        cols.delete_if { |col| !record.errors.invalid?(col) }
+        msg = build_message(message, "Active Record has invalid columns <?>)", cols.join(",") )
+        assert_block(msg) { cols.empty? }
+      end
+      deprecate :assert_valid_column_on_record => "use assert(!record.errors.invalid?(column)) instead"
+      # Assert the template object with the given name is an Active Record descendant and the specified column(s) are invalid.
+      def assert_invalid_column_on_record(key = nil, columns = "", message = nil) #:nodoc:
+        record = find_record_in_template(key)
+        record.send(:validate)
+        cols = glue_columns(columns)
+        cols.delete_if { |col| record.errors.invalid?(col) }
+        msg = build_message(message, "Active Record has valid columns <?>)", cols.join(",") )
+        assert_block(msg) { cols.empty? }
+      end
+      deprecate :assert_invalid_column_on_record => "use assert(record.errors.invalid?(column)) instead"
+      private
+        def glue_columns(columns)
+          cols = []
+          cols << columns if columns.class == String
+          cols += columns if columns.class == Array
+          cols
+        end
+        def find_record_in_template(key = nil)
+          assert_not_nil assigns(key)
+          record = @response.template_objects[key]
+          assert_not_nil(record)
+          assert_kind_of ActiveRecord::Base, record
+          return record
+        end
+    end
+  end
+end