will_paginate 3.2.0 → 4.0.0

data/spec/view_helpers/link_renderer_base_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-require 'will_paginate/view_helpers/link_renderer_base'
-require 'will_paginate/collection'
-
-describe WillPaginate::ViewHelpers::LinkRendererBase do
-  
-  before do
-    @renderer = described_class.new
-  end
-  
-  it "should raise error when unprepared" do
-    lambda {
-      @renderer.pagination
-    }.should raise_error
-  end
-  
-  it "should prepare with collection and options" do
-    prepare({})
-    @renderer.send(:current_page).should == 1
-  end
-  
-  it "should have total_pages accessor" do
-    prepare :total_pages => 42
-    @renderer.send(:total_pages).should == 42
-  end
-  
-  it "should clear old cached values when prepared" do
-    prepare(:total_pages => 1)
-    @renderer.send(:total_pages).should == 1
-    # prepare with different object:
-    prepare(:total_pages => 2)
-    @renderer.send(:total_pages).should == 2
-  end
-  
-  it "should have pagination definition" do
-    prepare({ :total_pages => 1 }, :page_links => true)
-    @renderer.pagination.should == [:previous_page, 1, :next_page]
-  end
-  
-  describe "visible page numbers" do
-    it "should calculate windowed visible links" do
-      prepare({ :page => 6, :total_pages => 11 }, :inner_window => 1, :outer_window => 1)
-      showing_pages 1, 2, :gap, 5, 6, 7, :gap, 10, 11
-    end
-  
-    it "should eliminate small gaps" do
-      prepare({ :page => 6, :total_pages => 11 }, :inner_window => 2, :outer_window => 1)
-      # pages 4 and 8 appear instead of the gap
-      showing_pages 1..11
-    end
-    
-    it "should support having no windows at all" do
-      prepare({ :page => 4, :total_pages => 7 }, :inner_window => 0, :outer_window => 0)
-      showing_pages 1, :gap, 4, :gap, 7
-    end
-    
-    it "should adjust upper limit if lower is out of bounds" do
-      prepare({ :page => 1, :total_pages => 10 }, :inner_window => 2, :outer_window => 1)
-      showing_pages 1, 2, 3, 4, 5, :gap, 9, 10
-    end
-    
-    it "should adjust lower limit if upper is out of bounds" do
-      prepare({ :page => 10, :total_pages => 10 }, :inner_window => 2, :outer_window => 1)
-      showing_pages 1, 2, :gap, 6, 7, 8, 9, 10
-    end
-    
-    def showing_pages(*pages)
-      pages = pages.first.to_a if Array === pages.first or Range === pages.first
-      @renderer.send(:windowed_page_numbers).should == pages
-    end
-  end
-  
-  protected
-
-    def collection(params = {})
-      if params[:total_pages]
-        params[:per_page] = 1
-        params[:total_entries] = params[:total_pages]
-      end
-      WillPaginate::Collection.new(params[:page] || 1, params[:per_page] || 30, params[:total_entries])
-    end
-
-    def prepare(collection_options, options = {})
-      @renderer.prepare(collection(collection_options), options)
-    end
-  
-end

data/spec/view_helpers/view_example_group.rb

@@ -1,146 +0,0 @@
-require 'active_support'
-require 'stringio'
-begin
-  $stderr = StringIO.new
-  require 'minitest/unit'
-rescue LoadError
-  # Fails on Ruby 1.8, but it's OK since we only need MiniTest::Assertions
-  # on Rails 4 which doesn't support 1.8 anyway.
-ensure
-  $stderr = STDERR
-end
-
-begin
-  require 'rails/dom/testing/assertions'
-rescue LoadError
-  require 'action_dispatch/testing/assertions'
-end
-require 'will_paginate/array'
-
-module ViewExampleGroup
-  
-  if defined?(Rails::Dom::Testing::Assertions)
-    include Rails::Dom::Testing::Assertions::SelectorAssertions
-  else
-    include ActionDispatch::Assertions::SelectorAssertions
-  end
-  include MiniTest::Assertions if defined? MiniTest
-
-  def assert(value, message)
-    raise message unless value
-  end
-  
-  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 }
-
-    @render_output = render(locals)
-    @html_document = nil
-    
-    if block_given?
-      classname = options[:class] || WillPaginate::ViewHelpers.pagination_options[:class]
-      assert_select("div.#{classname}", 1, 'no main DIV', &block)
-    end
-    
-    @render_output
-  end
-
-  def parse_html_document(html)
-    if defined?(Rails::Dom::Testing::Assertions)
-      Nokogiri::HTML::Document.parse(html)
-    else
-      HTML::Document.new(html, true, false)
-    end
-  end
-
-  def html_document
-    @html_document ||= parse_html_document(@render_output)
-  end
-
-  def document_root_element
-    html_document.root
-  end
-
-  def response_from_page_or_rjs
-    html_document.root
-  end
-  
-  def validate_page_numbers(expected, links, param_name = :page)
-    param_pattern = /\W#{Regexp.escape(param_name.to_s)}=([^&]*)/
-    
-    links.map { |el|
-      unescape_href(el) =~ param_pattern
-      $1 ? $1.to_i : $1
-    }.should == expected
-  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|
-      href = unescape_href(el)
-      href.should =~ pattern
-      if numbers
-        href =~ pattern
-        pages << ($1.nil?? nil : $1.to_i)
-      end
-    end
-
-    pages.should == numbers if numbers
-  end
-
-  def assert_no_links_match(pattern)
-    assert_select 'div.pagination a[href]' do |elements|
-      elements.each do |el|
-        unescape_href(el).should_not =~ pattern
-      end
-    end
-  end
-
-  def unescape_href(el)
-    CGI.unescape CGI.unescapeHTML(el['href'])
-  end
-  
-  def build_message(message, pattern, *args)
-    built_message = pattern.dup
-    for value in args
-      built_message.sub! '?', value.inspect
-    end
-    built_message
-  end
-  
-end
-
-RSpec.configure do |config|
-  config.include ViewExampleGroup, :type => :view, :example_group => {
-    :file_path => %r{spec/view_helpers/}
-  }
-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 if defined?(HTML)