refinerycms 0.9.6.19 → 0.9.6.21

data/vendor/plugins/will_paginate/test/fixtures/admin.rb

@@ -0,0 +1,3 @@
+class Admin < User
+  has_many :companies, :finder_sql => 'SELECT * FROM companies'
+end

data/vendor/plugins/will_paginate/test/fixtures/developer.rb

@@ -0,0 +1,14 @@
+class Developer < User
+  has_and_belongs_to_many :projects, :include => :topics, :order => 'projects.name'
+
+  def self.with_poor_ones(&block)
+    with_scope :find => { :conditions => ['salary <= ?', 80000], :order => 'salary' } do
+      yield
+    end
+  end
+
+  named_scope :distinct, :select => 'DISTINCT `users`.*'
+  named_scope :poor, :conditions => ['salary <= ?', 80000], :order => 'salary'
+
+  def self.per_page() 10 end
+end

data/vendor/plugins/will_paginate/test/fixtures/developers_projects.yml

@@ -0,0 +1,13 @@
+david_action_controller:
+  developer_id: 1
+  project_id: 2
+  joined_on: 2004-10-10
+
+david_active_record:
+  developer_id: 1
+  project_id: 1
+  joined_on: 2004-10-10
+
+jamis_active_record:
+  developer_id: 2
+  project_id: 1

data/vendor/plugins/will_paginate/test/fixtures/project.rb

@@ -0,0 +1,15 @@
+class Project < ActiveRecord::Base
+  has_and_belongs_to_many :developers, :uniq => true
+
+  has_many :topics
+    # :finder_sql  => 'SELECT * FROM topics WHERE (topics.project_id = #{id})',
+    # :counter_sql => 'SELECT COUNT(*) FROM topics WHERE (topics.project_id = #{id})'
+
+  has_many :replies, :through => :topics do
+    def find_recent(params = {})
+      with_scope :find => { :conditions => ['replies.created_at > ?', 15.minutes.ago] } do
+        find :all, params
+      end
+    end
+  end
+end

data/vendor/plugins/will_paginate/test/fixtures/projects.yml

@@ -0,0 +1,6 @@
+active_record:
+  id: 1
+  name: Active Record
+action_controller:
+  id: 2
+  name: Active Controller

data/vendor/plugins/will_paginate/test/fixtures/replies.yml

@@ -0,0 +1,29 @@
+witty_retort:
+  id: 1
+  topic_id: 1
+  content: Birdman is better!
+  created_at: <%= 6.hours.ago.to_s(:db) %>
+  
+another:
+  id: 2
+  topic_id: 2
+  content: Nuh uh!
+  created_at: <%= 1.hour.ago.to_s(:db) %>
+  
+spam:
+  id: 3
+  topic_id: 1
+  content: Nice site!
+  created_at: <%= 1.hour.ago.to_s(:db) %>
+
+decisive:
+  id: 4
+  topic_id: 4
+  content: "I'm getting to the bottom of this"
+  created_at: <%= 30.minutes.ago.to_s(:db) %>
+
+brave:
+  id: 5
+  topic_id: 4
+  content: "AR doesn't scare me a bit"
+  created_at: <%= 10.minutes.ago.to_s(:db) %>

data/vendor/plugins/will_paginate/test/fixtures/reply.rb

@@ -0,0 +1,7 @@
+class Reply < ActiveRecord::Base
+  belongs_to :topic, :include => [:replies]
+
+  named_scope :recent, :conditions => ['replies.created_at > ?', 15.minutes.ago]
+
+  validates_presence_of :content
+end

data/vendor/plugins/will_paginate/test/fixtures/schema.rb

@@ -0,0 +1,38 @@
+ActiveRecord::Schema.define do
+
+  create_table "users", :force => true do |t|
+    t.column "name",       :text
+    t.column "salary",     :integer,  :default => 70000
+    t.column "created_at", :datetime
+    t.column "updated_at", :datetime
+    t.column "type",       :text
+  end
+
+  create_table "projects", :force => true do |t|
+    t.column "name", :text
+  end
+
+  create_table "developers_projects", :id => false, :force => true do |t|
+    t.column "developer_id", :integer, :null => false
+    t.column "project_id",   :integer, :null => false
+    t.column "joined_on",    :date
+    t.column "access_level", :integer, :default => 1
+  end
+
+  create_table "topics", :force => true do |t|
+    t.column "project_id", :integer
+    t.column "title",      :string
+    t.column "subtitle",   :string
+    t.column "content",    :text
+    t.column "created_at", :datetime
+    t.column "updated_at", :datetime
+  end
+
+  create_table "replies", :force => true do |t|
+    t.column "content",    :text
+    t.column "created_at", :datetime
+    t.column "updated_at", :datetime
+    t.column "topic_id",   :integer
+  end
+
+end

data/vendor/plugins/will_paginate/test/fixtures/topic.rb

@@ -0,0 +1,10 @@
+class Topic < ActiveRecord::Base
+  has_many :replies, :dependent => :destroy, :order => 'replies.created_at DESC'
+  belongs_to :project
+
+  named_scope :mentions_activerecord, :conditions => ['topics.title LIKE ?', '%ActiveRecord%']
+
+  named_scope :with_replies_starting_with, lambda { |text|
+    { :conditions => "replies.content LIKE '#{text}%' ", :include  => :replies }
+  }
+end

data/vendor/plugins/will_paginate/test/fixtures/topics.yml

@@ -0,0 +1,30 @@
+futurama:
+  id: 1
+  title: Isnt futurama awesome?
+  subtitle: It really is, isnt it.
+  content: I like futurama
+  created_at: <%= 1.day.ago.to_s(:db) %>
+  updated_at:
+  
+harvey_birdman:
+  id: 2
+  title: Harvey Birdman is the king of all men
+  subtitle: yup
+  content: He really is
+  created_at: <%= 2.hours.ago.to_s(:db) %>
+  updated_at:
+
+rails:
+  id: 3
+  project_id: 1
+  title: Rails is nice
+  subtitle: It makes me happy
+  content: except when I have to hack internals to fix pagination. even then really.
+  created_at: <%= 20.minutes.ago.to_s(:db) %>
+
+ar:
+  id: 4
+  project_id: 1
+  title: ActiveRecord sometimes freaks me out
+  content: "I mean, what's the deal with eager loading?"
+  created_at: <%= 15.minutes.ago.to_s(:db) %>

data/vendor/plugins/will_paginate/test/fixtures/user.rb

@@ -0,0 +1,2 @@
+class User < ActiveRecord::Base
+end

data/vendor/plugins/will_paginate/test/fixtures/users.yml

@@ -0,0 +1,35 @@
+david:
+  id: 1
+  name: David
+  salary: 80000
+  type: Developer
+
+jamis:
+  id: 2
+  name: Jamis
+  salary: 150000
+  type: Developer
+
+<% for digit in 3..10 %>
+dev_<%= digit %>:
+  id: <%= digit %>
+  name: fixture_<%= digit %>
+  salary: 100000
+  type: Developer
+<% end %>
+
+poor_jamis:
+  id: 11
+  name: Jamis
+  salary: 9000
+  type: Developer
+
+admin:
+  id: 12
+  name: admin
+  type: Admin
+
+goofy:
+  id: 13
+  name: Goofy
+  type: Admin

data/vendor/plugins/will_paginate/test/helper.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'rubygems'
+
+# gem install redgreen for colored test output
+begin require 'redgreen'; rescue LoadError; end
+
+require 'boot' unless defined?(ActiveRecord)
+
+class Test::Unit::TestCase
+  protected
+  def assert_respond_to_all object, methods
+    methods.each do |method|
+      [method.to_s, method.to_sym].each { |m| assert_respond_to object, m }
+    end
+  end
+
+  def collect_deprecations
+    old_behavior = WillPaginate::Deprecation.behavior
+    deprecations = []
+    WillPaginate::Deprecation.behavior = Proc.new do |message, callstack|
+      deprecations << message
+    end
+    result = yield
+    [result, deprecations]
+  ensure
+    WillPaginate::Deprecation.behavior = old_behavior
+  end
+end
+
+# Wrap tests that use Mocha and skip if unavailable.
+def uses_mocha(test_name)
+  require 'mocha'
+rescue LoadError
+  $stderr.puts "Skipping #{test_name} tests. `gem install mocha` and try again."
+else
+  yield
+end

data/vendor/plugins/will_paginate/test/lib/activerecord_test_case.rb

@@ -0,0 +1,43 @@
+require 'lib/activerecord_test_connector'
+
+class ActiveRecordTestCase < Test::Unit::TestCase
+  if defined?(ActiveSupport::Testing::SetupAndTeardown)
+    include ActiveSupport::Testing::SetupAndTeardown
+  end
+
+  if defined?(ActiveRecord::TestFixtures)
+    include ActiveRecord::TestFixtures
+  end
+  # Set our fixture path
+  if ActiveRecordTestConnector.able_to_connect
+    self.fixture_path = File.join(File.dirname(__FILE__), '..', 'fixtures')
+    self.use_transactional_fixtures = true
+  end
+
+  def self.fixtures(*args)
+    super if ActiveRecordTestConnector.connected
+  end
+
+  def run(*args)
+    super if ActiveRecordTestConnector.connected
+  end
+
+  # Default so Test::Unit::TestCase doesn't complain
+  def test_truth
+  end
+
+  protected
+
+    def assert_queries(num = 1)
+      $query_count = 0
+      yield
+    ensure
+      assert_equal num, $query_count, "#{$query_count} instead of #{num} queries were executed."
+    end
+
+    def assert_no_queries(&block)
+      assert_queries(0, &block)
+    end
+end
+
+ActiveRecordTestConnector.setup

data/vendor/plugins/will_paginate/test/lib/activerecord_test_connector.rb

@@ -0,0 +1,75 @@
+require 'active_record'
+require 'active_record/version'
+require 'active_record/fixtures'
+
+class ActiveRecordTestConnector
+  cattr_accessor :able_to_connect
+  cattr_accessor :connected
+
+  FIXTURES_PATH = File.join(File.dirname(__FILE__), '..', 'fixtures')
+
+  # Set our defaults
+  self.connected = false
+  self.able_to_connect = true
+
+  def self.setup
+    unless self.connected || !self.able_to_connect
+      setup_connection
+      load_schema
+      add_load_path FIXTURES_PATH
+      self.connected = true
+    end
+  rescue Exception => e  # errors from ActiveRecord setup
+    $stderr.puts "\nSkipping ActiveRecord tests: #{e}\n\n"
+    self.able_to_connect = false
+  end
+
+  private
+
+  def self.add_load_path(path)
+    dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
+    dep.load_paths.unshift path
+  end
+
+  def self.setup_connection
+    db = ENV['DB'].blank?? 'sqlite3' : ENV['DB']
+
+    configurations = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'database.yml'))
+    raise "no configuration for '#{db}'" unless configurations.key? db
+    configuration = configurations[db]
+
+    ActiveRecord::Base.logger = Logger.new(STDOUT) if $0 == 'irb'
+    puts "using #{configuration['adapter']} adapter" unless ENV['DB'].blank?
+
+    gem 'sqlite3-ruby' if 'sqlite3' == db
+
+    ActiveRecord::Base.establish_connection(configuration)
+    ActiveRecord::Base.configurations = { db => configuration }
+    prepare ActiveRecord::Base.connection
+
+    unless Object.const_defined?(:QUOTED_TYPE)
+      Object.send :const_set, :QUOTED_TYPE, ActiveRecord::Base.connection.quote_column_name('type')
+    end
+  end
+
+  def self.load_schema
+    ActiveRecord::Base.silence do
+      ActiveRecord::Migration.verbose = false
+      load File.join(FIXTURES_PATH, 'schema.rb')
+    end
+  end
+
+  def self.prepare(conn)
+    class << conn
+      IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SHOW FIELDS /]
+
+      def execute_with_counting(sql, name = nil, &block)
+        $query_count ||= 0
+        $query_count  += 1 unless IGNORED_SQL.any? { |r| sql =~ r }
+        execute_without_counting(sql, name, &block)
+      end
+
+      alias_method_chain :execute, :counting
+    end
+  end
+end

data/vendor/plugins/will_paginate/test/lib/load_fixtures.rb

@@ -0,0 +1,11 @@
+require 'boot'
+require 'lib/activerecord_test_connector'
+
+# setup the connection
+ActiveRecordTestConnector.setup
+
+# load all fixtures
+Fixtures.create_fixtures(ActiveRecordTestConnector::FIXTURES_PATH, ActiveRecord::Base.connection.tables)
+
+require 'will_paginate'
+WillPaginate.enable_activerecord

data/vendor/plugins/will_paginate/test/lib/view_test_process.rb

@@ -0,0 +1,179 @@
+require 'will_paginate/core_ext'
+require 'action_controller'
+require 'action_controller/test_process'
+
+require 'will_paginate'
+WillPaginate.enable_actionpack
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect 'dummy/page/:page', :controller => 'dummy'
+  map.connect 'dummy/dots/page.:page', :controller => 'dummy', :action => 'dots'
+  map.connect 'ibocorp/:page', :controller => 'ibocorp',
+                               :requirements => { :page => /\d+/ },
+                               :defaults => { :page => 1 }
+
+  map.connect ':controller/:action/:id'
+end
+
+ActionController::Base.perform_caching = false
+
+class WillPaginate::ViewTestCase < Test::Unit::TestCase
+  if defined?(ActionController::TestCase::Assertions)
+    include ActionController::TestCase::Assertions
+  end
+  if defined?(ActiveSupport::Testing::Deprecation)
+    include ActiveSupport::Testing::Deprecation
+  end
+
+  def setup
+    super
+    @controller  = DummyController.new
+    @request     = @controller.request
+    @html_result = nil
+    @template    = '<%= will_paginate collection, options %>'
+
+    @view = ActionView::Base.new
+    @view.assigns['controller'] = @controller
+    @view.assigns['_request']   = @request
+    @view.assigns['_params']    = @request.params
+  end
+
+  def test_no_complain; end
+
+  protected
+
+    def paginate(collection = {}, options = {}, &block)
+      if collection.instance_of? Hash
+        page_options = { :page => 1, :total_entries => 11, :per_page => 4 }.merge(collection)
+        collection = [1].paginate(page_options)
+      end
+
+      locals = { :collection => collection, :options => options }
+
+      unless @view.respond_to? :render_template
+        # Rails 2.2
+        @html_result = ActionView::InlineTemplate.new(@template).render(@view, locals)
+      else
+        if defined? ActionView::InlineTemplate
+          # Rails 2.1
+          args = [ ActionView::InlineTemplate.new(@view, @template, locals) ]
+        else
+          # older Rails versions
+          args = [nil, @template, nil, locals]
+        end
+
+        @html_result = @view.render_template(*args)
+      end
+
+      @html_document = HTML::Document.new(@html_result, true, false)
+
+      if block_given?
+        classname = options[:class] || WillPaginate::ViewHelpers.pagination_options[:class]
+        assert_select("div.#{classname}", 1, 'no main DIV', &block)
+      end
+    end
+
+    def response_from_page_or_rjs
+      @html_document.root
+    end
+
+    def validate_page_numbers expected, links, param_name = :page
+      param_pattern = /\W#{CGI.escape(param_name.to_s)}=([^&]*)/
+
+      assert_equal(expected, links.map { |e|
+        e['href'] =~ param_pattern
+        $1 ? $1.to_i : $1
+      })
+    end
+
+    def assert_links_match pattern, links = nil, numbers = nil
+      links ||= assert_select 'div.pagination a[href]' do |elements|
+        elements
+      end
+
+      pages = [] if numbers
+
+      links.each do |el|
+        assert_match pattern, el['href']
+        if numbers
+          el['href'] =~ pattern
+          pages << ($1.nil?? nil : $1.to_i)
+        end
+      end
+
+      assert_equal numbers, pages, "page numbers don't match" if numbers
+    end
+
+    def assert_no_links_match pattern
+      assert_select 'div.pagination a[href]' do |elements|
+        elements.each do |el|
+          assert_no_match pattern, el['href']
+        end
+      end
+    end
+end
+
+class DummyRequest
+  attr_accessor :symbolized_path_parameters
+
+  def initialize
+    @get = true
+    @params = {}
+    @symbolized_path_parameters = { :controller => 'foo', :action => 'bar' }
+  end
+
+  def get?
+    @get
+  end
+
+  def post
+    @get = false
+  end
+
+  def relative_url_root
+    ''
+  end
+
+  def params(more = nil)
+    @params.update(more) if more
+    @params
+  end
+end
+
+class DummyController
+  attr_reader :request
+  attr_accessor :controller_name
+
+  def initialize
+    @request = DummyRequest.new
+    @url = ActionController::UrlRewriter.new(@request, @request.params)
+  end
+
+  def params
+    @request.params
+  end
+
+  def url_for(params)
+    @url.rewrite(params)
+  end
+end
+
+module HTML
+  Node.class_eval do
+    def inner_text
+      children.map(&:inner_text).join('')
+    end
+  end
+
+  Text.class_eval do
+    def inner_text
+      self.to_s
+    end
+  end
+
+  Tag.class_eval do
+    def inner_text
+      childless?? '' : super
+    end
+  end
+end