backlog 0.37.2 → 0.41.4

data/vendor/plugins/rails_time/test/database.yml

@@ -1,18 +0,0 @@
-sqlite:
-  :adapter: sqlite
-  :dbfile: plugin.sqlite.db
-sqlite3:
-  :adapter: sqlite3
-  :dbfile: ":memory:"
-postgresql:
-  :adapter: postgresql
-  :username: postgres
-  :password: postgres
-  :database: plugin_test
-  :min_messages: ERROR
-mysql:
-  :adapter: mysql
-  :host: localhost
-  :username: rails
-  :password:
-  :database: plugin_test

data/vendor/plugins/rails_time/test/debug.log

@@ -1 +0,0 @@
-# Logfile created on Wed Nov 10 13:02:45 +0100 2010 by logger.rb/99999

data/vendor/plugins/rails_time/test/rails_time_test.rb

@@ -1,122 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class Thing < ActiveRecord::Base
-end
-
-def thing
-  Thing.new(:name => "Thing One",:price_in_cents=> 125)
-end
-
-class RailsMoneyTest < Test::Unit::TestCase
-  
-  def test_should_return_price_as_money_object
-    price = thing.price
-    assert_kind_of Money, price
-    assert_equal "$1.25", thing.price.to_s
-  end
-  
-  def test_should_set_price_from_money_object
-    thing1 = thing 
-    thing1.price = Money.new(1095)
-    assert_equal 109500, thing1.price_in_cents
-    assert_equal "$1,095.00", thing1.price.to_s
-  end
-
-  def test_should_set_price_from_fixnum
-    thing1 = thing
-    thing1.price = 1095
-    assert_equal 109500, thing1.price_in_cents
-  end
-
-  def test_should_set_price_from_float
-    thing1 = thing
-    thing1.price = 10.95
-    assert_equal 1095, thing1.price_in_cents
-  end
-  
-  def test_should_set_price_from_string
-    thing1 = thing
-    thing1.price = "$10.95"
-    assert_equal 1095, thing1.price_in_cents
-    thing1.price = "10"
-    assert_equal 1000, thing1.price_in_cents
-  end
-
-  def test_should_format_correctly
-    assert_equal "$12.40", Money.new(12.40).to_s
-  end
-
-  def test_should_raise_exception_setting_invalid_price
-    assert_raise(MoneyError) { thing.price = [] }
-  end
-end
-
-class MoneyTest < Test::Unit::TestCase
-   
-  def test_should_create_money_object
-    assert cash_money = Money.new(1290)
-    assert_equal 129000, cash_money.cents
-    assert_equal 1290, cash_money.dollars
-    assert_equal "$1,290.00", cash_money.to_s
-    assert_equal false, cash_money.free?
-    assert_equal 0, Money.new(nil).cents
-  end
-
-  def test_should_create_money_object_from_float_with_proper_rounding
-    money =  Money.new(12.196)
-    assert_equal 1220, money.cents
-    assert_instance_of Fixnum, money.cents 
-  end
-  
-  def test_should_raise_exception_if_invalid_type_passed_to_initialize
-    assert_raise(MoneyError) { Money.new([]) }
-  end
-
-  def test_should_return_free_on_to_s_if_cents_is_zero
-    cash_money = Money.new(0)
-    assert_equal 'free', cash_money.to_s
-    assert_equal true, cash_money.free?
-    assert_equal true, cash_money.zero?
-  end
-
-  def test_should_be_comparable
-    assert Money.include?(Comparable)
-    assert Money.new(0) == Money.new(0)
-  end
-
-  def test_should_add_money
-    assert_equal Money.new(20.95), Money.new(10) + Money.new(10.95)
-    assert_equal Money.new(2000), Money.new(1000) + 1000
-    assert_equal Money.new(20.06), Money.new(10.00) + 10.056
-  end
-
-  def test_should_subtract_money
-    assert_equal Money.new(500), Money.new(1000) - Money.new(500)
-    assert_equal Money.new(500),  Money.new(1000) - 500
-    assert_equal Money.new(4.60),  Money.new(10) - 5.40
-  end
-
-  def test_should_multiply_money
-    assert_equal Money.new(500), Money.new(100) * 5
-    assert_equal Money.new(9.99), Money.new(3.33) * 3
-    assert_equal Money.new(11.99), Money.new(3.33) * 3.6 # 1198.9
-  end
-
-  def test_should_divide_money_and_retur_array_of_monies
-    money_array = [Money.new(3.34), Money.new(3.33), Money.new(3.33)]
-    assert_equal money_array, Money.new(10.00) / 3
-    assert_equal [Money.new(2.00), Money.new(2.00)], Money.new(4.00) / 2
-    assert_raises(MoneyError) { Money.new(4.00) / 2.2 }
-  end
-
-  def test_should_implement_to_money
-    assert_equal Money.new(10), Money.new(10).to_money
-    assert_equal Money.new(100.00), 100.00.to_money
-    assert_equal Money.new(100.96), 100.956.to_money
-  end
-  
-  def test_should_create_from_cents
-    assert_equal Money.new(1.50), Money.create_from_cents(150)
-  end
-
-end

data/vendor/plugins/rails_time/test/schema.rb

@@ -1,10 +0,0 @@
-ActiveRecord::Schema.define(:version => 1) do
-  
-  # Create tables for testing your plugin
-
-   create_table :things do |t|
-     t.column :name,   :string
-     t.column :price_in_cents, :integer
-   end
-    
-end

data/vendor/plugins/rails_time/test/test_helper.rb

@@ -1,17 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-RAILS_ROOT = File.dirname(__FILE__)
-
-require 'rubygems'
-require 'test/unit'
-require 'active_record'
-require "#{File.dirname(__FILE__)}/../init"
-
-config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
-ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
-ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3'])
-
-load(File.dirname(__FILE__) + "/schema.rb") if File.exist?(File.dirname(__FILE__) + "/schema.rb")
-
-
-
-

data/vendor/plugins/verification/MIT-LICENSE

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

data/vendor/plugins/verification/README

@@ -1,34 +0,0 @@
-This module provides a class-level method for specifying that certain
-actions are guarded against being called without certain prerequisites
-being met. This is essentially a special kind of before_filter.
-
-An action may be guarded against being invoked without certain request
-parameters being set, or without certain session values existing.
-
-When a verification is violated, values may be inserted into the flash, and
-a specified redirection is triggered. If no specific action is configured,
-verification failures will by default result in a 400 Bad Request response.
-
-Usage:
-
-  class GlobalController < ActionController::Base
-    # Prevent the #update_settings action from being invoked unless
-    # the 'admin_privileges' request parameter exists. The
-    # settings action will be redirected to in current controller
-    # if verification fails.
-    verify :params => "admin_privileges", :only => :update_post,
-           :redirect_to => { :action => "settings" }
-
-    # Disallow a post from being updated if there was no information
-    # submitted with the post, and if there is no active post in the
-    # session, and if there is no "note" key in the flash. The route
-    # named category_url will be redirected to if verification fails.
-
-    verify :params => "post", :session => "post", "flash" => "note",
-           :only => :update_post,
-           :add_flash => { "alert" => "Failed to create your message" },
-           :redirect_to => :category_url
-
-Note that these prerequisites are not business rules. They do not examine
-the content of the session or the parameters. That level of validation should
-be encapsulated by your domain model or helper methods in the controller.

data/vendor/plugins/verification/Rakefile

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

data/vendor/plugins/verification/init.rb

@@ -1,3 +0,0 @@
-# Include hook code here
-
-require 'action_controller/verification'

data/vendor/plugins/verification/lib/action_controller/verification.rb

@@ -1,132 +0,0 @@
-module ActionController #:nodoc:
-  module Verification #:nodoc:
-    extend ActiveSupport::Concern
-
-    include AbstractController::Callbacks, Flash, Rendering
-
-    # This module provides a class-level method for specifying that certain
-    # actions are guarded against being called without certain prerequisites
-    # being met. This is essentially a special kind of before_filter.
-    #
-    # An action may be guarded against being invoked without certain request
-    # parameters being set, or without certain session values existing.
-    #
-    # When a verification is violated, values may be inserted into the flash, and
-    # a specified redirection is triggered. If no specific action is configured,
-    # verification failures will by default result in a 400 Bad Request response.
-    #
-    # Usage:
-    #
-    #   class GlobalController < ActionController::Base
-    #     # Prevent the #update_settings action from being invoked unless
-    #     # the 'admin_privileges' request parameter exists. The
-    #     # settings action will be redirected to in current controller
-    #     # if verification fails.
-    #     verify :params => "admin_privileges", :only => :update_post,
-    #            :redirect_to => { :action => "settings" }
-    #
-    #     # Disallow a post from being updated if there was no information
-    #     # submitted with the post, and if there is no active post in the
-    #     # session, and if there is no "note" key in the flash. The route
-    #     # named category_url will be redirected to if verification fails.
-    #
-    #     verify :params => "post", :session => "post", "flash" => "note",
-    #            :only => :update_post,
-    #            :add_flash => { "alert" => "Failed to create your message" },
-    #            :redirect_to => :category_url
-    #
-    # Note that these prerequisites are not business rules. They do not examine
-    # the content of the session or the parameters. That level of validation should
-    # be encapsulated by your domain model or helper methods in the controller.
-    module ClassMethods
-      # Verify the given actions so that if certain prerequisites are not met,
-      # the user is redirected to a different action. The +options+ parameter
-      # is a hash consisting of the following key/value pairs:
-      #
-      # <tt>:params</tt>::
-      #   a single key or an array of keys that must be in the <tt>params</tt>
-      #   hash in order for the action(s) to be safely called.
-      # <tt>:session</tt>::
-      #   a single key or an array of keys that must be in the <tt>session</tt>
-      #   in order for the action(s) to be safely called.
-      # <tt>:flash</tt>::
-      #   a single key or an array of keys that must be in the flash in order
-      #   for the action(s) to be safely called.
-      # <tt>:method</tt>::
-      #   a single key or an array of keys--any one of which must match the
-      #   current request method in order for the action(s) to be safely called.
-      #   (The key should be a symbol: <tt>:get</tt> or <tt>:post</tt>, for
-      #   example.)
-      # <tt>:xhr</tt>::
-      #   true/false option to ensure that the request is coming from an Ajax
-      #   call or not.
-      # <tt>:add_flash</tt>::
-      #   a hash of name/value pairs that should be merged into the session's
-      #   flash if the prerequisites cannot be satisfied.
-      # <tt>:add_headers</tt>::
-      #   a hash of name/value pairs that should be merged into the response's
-      #   headers hash if the prerequisites cannot be satisfied.
-      # <tt>:redirect_to</tt>::
-      #   the redirection parameters to be used when redirecting if the
-      #   prerequisites cannot be satisfied. You can redirect either to named
-      #   route or to the action in some controller.
-      # <tt>:render</tt>::
-      #   the render parameters to be used when the prerequisites cannot be satisfied.
-      # <tt>:only</tt>::
-      #   only apply this verification to the actions specified in the associated
-      #   array (may also be a single value).
-      # <tt>:except</tt>::
-      #   do not apply this verification to the actions specified in the associated
-      #   array (may also be a single value).
-      def verify(options={})
-        before_filter :only => options[:only], :except => options[:except] do
-          verify_action options
-        end
-      end
-    end
-
-  private
-
-    def verify_action(options) #:nodoc:
-      if prereqs_invalid?(options)
-        flash.update(options[:add_flash])              if options[:add_flash]
-        response.headers.merge!(options[:add_headers]) if options[:add_headers]
-        apply_remaining_actions(options)               unless performed?
-      end
-    end
-
-    def prereqs_invalid?(options) # :nodoc:
-      verify_presence_of_keys_in_hash_flash_or_params(options) ||
-      verify_method(options) ||
-      verify_request_xhr_status(options)
-    end
-
-    def verify_presence_of_keys_in_hash_flash_or_params(options) # :nodoc:
-      [*options[:params] ].find { |v| v && params[v.to_sym].nil?  } ||
-      [*options[:session]].find { |v| session[v].nil? } ||
-      [*options[:flash]  ].find { |v| flash[v].nil?   }
-    end
-
-    def verify_method(options) # :nodoc:
-      [*options[:method]].all? { |v| request.method_symbol != v.to_sym } if options[:method]
-    end
-
-    def verify_request_xhr_status(options) # :nodoc:
-      request.xhr? != options[:xhr] unless options[:xhr].nil?
-    end
-
-    def apply_redirect_to(redirect_to_option) # :nodoc:
-      (redirect_to_option.is_a?(Symbol) && redirect_to_option != :back) ? self.__send__(redirect_to_option) : redirect_to_option
-    end
-
-    def apply_remaining_actions(options) # :nodoc:
-      case
-        when options[:render]      ; render(options[:render])
-        when options[:redirect_to] ; redirect_to(apply_redirect_to(options[:redirect_to]))
-        else head(:bad_request)
-      end
-    end
-  end
-end
-
-ActionController::Base.send :include, ActionController::Verification

data/vendor/plugins/verification/test/test_helper.rb

@@ -1,18 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'active_support'
-require 'action_controller'
-require File.dirname(__FILE__) + '/../lib/action_controller/verification'
-
-SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
-SharedTestRoutes.draw do |map|
-  map.connect ":controller/:action/:id"
-end
-
-ActionController::Base.send :include, SharedTestRoutes.url_helpers
-
-module ActionController
-  class TestCase
-    setup { @routes = SharedTestRoutes }
-  end
-end

data/vendor/plugins/verification/test/verification_test.rb

@@ -1,270 +0,0 @@
-require 'test_helper'
-
-class VerificationTestController < ActionController::Base
-  verify :only => :guarded_one, :params => "one",
-         :add_flash => { :error => 'unguarded' },
-         :redirect_to => { :action => "unguarded" }
-
-  verify :only => :guarded_two, :params => %w( one two ),
-         :redirect_to => { :action => "unguarded" }
-
-  verify :only => :guarded_with_flash, :params => "one",
-         :add_flash => { :notice => "prereqs failed" },
-         :redirect_to => { :action => "unguarded" }
-
-  verify :only => :guarded_in_session, :session => "one",
-         :redirect_to => { :action => "unguarded" }
-
-  verify :only => [:multi_one, :multi_two], :session => %w( one two ),
-         :redirect_to => { :action => "unguarded" }
-
-  verify :only => :guarded_by_method, :method => :post,
-         :redirect_to => { :action => "unguarded" }
-
-  verify :only => :guarded_by_xhr, :xhr => true,
-         :redirect_to => { :action => "unguarded" }
-
-  verify :only => :guarded_by_not_xhr, :xhr => false,
-         :redirect_to => { :action => "unguarded" }
-
-  before_filter :unconditional_redirect, :only => :two_redirects
-  verify :only => :two_redirects, :method => :post,
-         :redirect_to => { :action => "unguarded" }
-
-  verify :only => :must_be_post, :method => :post, :render => { :status => 405, :text => "Must be post" }, :add_headers => { "Allow" => "POST" }
-
-  verify :only => :guarded_one_for_named_route_test, :params => "one",
-         :redirect_to => :foo_url
-
-  verify :only => :no_default_action, :params => "santa"
-
-  verify :only => :guarded_with_back, :method => :post,
-         :redirect_to => :back
-
-  def guarded_one
-    render :text => "#{params[:one]}"
-  end
-
-  def guarded_one_for_named_route_test
-    render :text => "#{params[:one]}"
-  end
-
-  def guarded_with_flash
-    render :text => "#{params[:one]}"
-  end
-
-  def guarded_two
-    render :text => "#{params[:one]}:#{params[:two]}"
-  end
-
-  def guarded_in_session
-    render :text => "#{session["one"]}"
-  end
-
-  def multi_one
-    render :text => "#{session["one"]}:#{session["two"]}"
-  end
-
-  def multi_two
-    render :text => "#{session["two"]}:#{session["one"]}"
-  end
-
-  def guarded_by_method
-    render :text => "#{request.method}"
-  end
-
-  def guarded_by_xhr
-    render :text => "#{request.xhr?}"
-  end
-
-  def guarded_by_not_xhr
-    render :text => "#{request.xhr?}"
-  end
-
-  def unguarded
-    render :text => "#{params[:one]}"
-  end
-
-  def two_redirects
-    render :nothing => true
-  end
-
-  def must_be_post
-    render :text => "Was a post!"
-  end
-
-  def guarded_with_back
-    render :text => "#{params[:one]}"
-  end
-
-  def no_default_action
-    # Will never run
-  end
-
-  protected
-
-  def unconditional_redirect
-    redirect_to :action => "unguarded"
-  end
-end
-
-class VerificationTest < ActionController::TestCase
-  tests ::VerificationTestController
-
-  def test_using_symbol_back_with_no_referrer
-    assert_raise(ActionController::RedirectBackError) { get :guarded_with_back }
-  end
-
-  def test_using_symbol_back_redirects_to_referrer
-    @request.env["HTTP_REFERER"] = "/foo"
-    get :guarded_with_back
-    assert_redirected_to '/foo'
-  end
-
-  def test_no_deprecation_warning_for_named_route
-    assert_not_deprecated do
-      with_routing do |set|
-        set.draw do |map|
-          match 'foo', :to => 'test#foo', :as => :foo
-          match 'verification_test/:action', :to => ::VerificationTestController
-        end
-        get :guarded_one_for_named_route_test, :two => "not one"
-        assert_redirected_to '/foo'
-      end
-    end
-  end
-
-  def test_guarded_one_with_prereqs
-    get :guarded_one, :one => "here"
-    assert_equal "here", @response.body
-  end
-
-  def test_guarded_one_without_prereqs
-    get :guarded_one
-    assert_redirected_to :action => "unguarded"
-    assert_equal 'unguarded', flash[:error]
-  end
-
-  def test_guarded_with_flash_with_prereqs
-    get :guarded_with_flash, :one => "here"
-    assert_equal "here", @response.body
-    assert flash.empty?
-  end
-
-  def test_guarded_with_flash_without_prereqs
-    get :guarded_with_flash
-    assert_redirected_to :action => "unguarded"
-    assert_equal "prereqs failed", flash[:notice]
-  end
-
-  def test_guarded_two_with_prereqs
-    get :guarded_two, :one => "here", :two => "there"
-    assert_equal "here:there", @response.body
-  end
-
-  def test_guarded_two_without_prereqs_one
-    get :guarded_two, :two => "there"
-    assert_redirected_to :action => "unguarded"
-  end
-
-  def test_guarded_two_without_prereqs_two
-    get :guarded_two, :one => "here"
-    assert_redirected_to :action => "unguarded"
-  end
-
-  def test_guarded_two_without_prereqs_both
-    get :guarded_two
-    assert_redirected_to :action => "unguarded"
-  end
-
-  def test_unguarded_with_params
-    get :unguarded, :one => "here"
-    assert_equal "here", @response.body
-  end
-
-  def test_unguarded_without_params
-    get :unguarded
-    assert @response.body.blank?
-  end
-
-  def test_guarded_in_session_with_prereqs
-    get :guarded_in_session, {}, "one" => "here"
-    assert_equal "here", @response.body
-  end
-
-  def test_guarded_in_session_without_prereqs
-    get :guarded_in_session
-    assert_redirected_to :action => "unguarded"
-  end
-
-  def test_multi_one_with_prereqs
-    get :multi_one, {}, "one" => "here", "two" => "there"
-    assert_equal "here:there", @response.body
-  end
-
-  def test_multi_one_without_prereqs
-    get :multi_one
-    assert_redirected_to :action => "unguarded"
-  end
-
-  def test_multi_two_with_prereqs
-    get :multi_two, {}, "one" => "here", "two" => "there"
-    assert_equal "there:here", @response.body
-  end
-
-  def test_multi_two_without_prereqs
-    get :multi_two
-    assert_redirected_to :action => "unguarded"
-  end
-
-  def test_guarded_by_method_with_prereqs
-    post :guarded_by_method
-    assert_equal "POST", @response.body
-  end
-
-  def test_guarded_by_method_without_prereqs
-    get :guarded_by_method
-    assert_redirected_to :action => "unguarded"
-  end
-
-  def test_guarded_by_xhr_with_prereqs
-    xhr :post, :guarded_by_xhr
-    assert_equal "true", @response.body
-  end
-
-  def test_guarded_by_xhr_without_prereqs
-    get :guarded_by_xhr
-    assert_redirected_to :action => "unguarded"
-  end
-
-  def test_guarded_by_not_xhr_with_prereqs
-    get :guarded_by_not_xhr
-    assert_equal "false", @response.body
-  end
-
-  def test_guarded_by_not_xhr_without_prereqs
-    xhr :post, :guarded_by_not_xhr
-    assert_redirected_to :action => "unguarded"
-  end
-
-  def test_guarded_post_and_calls_render_succeeds
-    post :must_be_post
-    assert_equal "Was a post!", @response.body
-  end
-
-  def test_default_failure_should_be_a_bad_request
-    post :no_default_action
-    assert_response :bad_request
-  end
-
-  def test_guarded_post_and_calls_render_fails_and_sets_allow_header
-    get :must_be_post
-    assert_response 405
-    assert_equal "Must be post", @response.body
-    assert_equal "POST", @response.headers["Allow"]
-  end
-
-  def test_second_redirect
-    assert_nothing_raised { get :two_redirects }
-  end
-end