folio-pagination-legacy 0.0.2

data/test/folio/per_page_test.rb

@@ -0,0 +1,49 @@
+require 'minitest/autorun'
+require 'folio/per_page'
+require 'folio'
+
+describe Folio::PerPage do
+  before do
+    @klass = Class.new{ include Folio::PerPage }
+    @object = @klass.new
+  end
+
+  describe "default_per_page" do
+    it "should be Folio.per_page" do
+      was = Folio.per_page
+      Folio.per_page = 100
+      @object.default_per_page.must_equal 100
+      Folio.per_page = was
+    end
+  end
+
+  describe "per_page" do
+    it "should return default_per_page if nil" do
+      @klass.send(:define_method, :default_per_page) { 100 }
+      @object.per_page = nil
+      @object.per_page.must_equal 100
+    end
+
+    it "should return set value if non-nil" do
+      @object.per_page = 100
+      @object.per_page.must_equal 100
+    end
+
+    it "should allow setting through argument" do
+      @object.per_page(100)
+      @object.per_page.must_equal 100
+    end
+
+    it "should cast to integer when setting non-nil through argument" do
+      @object.per_page("100")
+      @object.per_page.must_equal 100
+    end
+
+    it "should allow setting to nil through argument" do
+      @klass.send(:define_method, :default_per_page) { 100 }
+      @object.per_page(30)
+      @object.per_page(nil)
+      @object.per_page.must_equal 100
+    end
+  end
+end

data/test/folio/rails_test.rb

@@ -0,0 +1,11 @@
+require 'folio/rails'
+require 'folio/invalid_page'
+require 'action_controller/base'
+
+describe ActionController::Base do
+  it "should translate Folio::InvalidPage to a 404" do
+    controller = ActionController::Base.new
+    code = controller.send :response_code_for_rescue, Folio::InvalidPage.new
+    code.must_equal :not_found
+  end
+end

data/test/folio/version_test.rb

@@ -0,0 +1,8 @@
+require 'minitest/autorun'
+require 'folio/version'
+
+describe Folio::VERSION do
+  it "should have a version" do
+    Folio::VERSION.wont_be_nil
+  end
+end

data/test/folio/will_paginate/active_record_test.rb

@@ -0,0 +1,113 @@
+require 'minitest/autorun'
+require 'folio/will_paginate/active_record'
+require_relative '../../setup/active_record'
+
+describe ActiveRecord do
+  TestSetup::ActiveRecord.migrate do |m|
+    m.create_table(:items) do |t|
+      t.boolean :filter
+    end
+
+    m.create_table(:related_things) do |t|
+      t.integer :item_id
+    end
+  end
+
+  class Item < ::ActiveRecord::Base
+    has_many :related_things
+  end
+
+  class RelatedThing < ::ActiveRecord::Base; end
+
+  before do
+    RelatedThing.delete_all
+    Item.delete_all
+    24.times{ |i| Item.create(filter: (i % 2).zero?) }
+  end
+
+  describe "per_page" do
+    it "should default to Folio.per_page" do
+      was = Folio.per_page
+      Folio.per_page = 10
+      ActiveRecord::Base.per_page.must_equal 10
+      Folio.per_page = was
+    end
+  end
+
+  describe "paginate" do
+    it "should return an ordinal folio page" do
+      page = Item.paginate
+      page.is_a?(Folio::Ordinal::Page).must_equal true
+    end
+
+    it "should set per_page from parameter" do
+      page = Item.paginate(per_page: 10)
+      page.per_page.must_equal 10
+    end
+
+    it "should default per_page to model's per_page" do
+      was = Item.per_page
+      Item.per_page = 10
+      page = Item.paginate
+      page.per_page.must_equal 10
+      Item.per_page = was
+    end
+
+    it "should set offset from page and per_page" do
+      page = Item.paginate(page: 3, per_page: 10)
+      page.offset.must_equal 20
+    end
+
+    it "should set current_page" do
+      page = Item.paginate(page: 3, per_page: 10)
+      page.current_page.must_equal 3
+    end
+
+    it "should have the right size on the page" do
+      page = Item.paginate(page: 3, per_page: 10)
+      page.size.must_equal 4
+    end
+
+    it "should return the expected items" do
+      page = Item.paginate(page: 3, per_page: 10)
+      page.to_a.must_equal Item.find(:all, offset: 20, limit: 10)
+    end
+
+    it "should auto-count total_entries unless specified as nil" do
+      page = Item.paginate
+      page.total_entries.must_equal 24
+    end
+
+    it "should not auto-count total_entries when specified as nil and not last page" do
+      page = Item.paginate(per_page: 10, total_entries: nil)
+      page.total_entries.must_be_nil
+    end
+
+    it "should calculate total_entries when specified as nil but last page" do
+      page = Item.paginate(page: 3, per_page: 10, total_entries: nil)
+      page.total_entries.must_equal 24
+    end
+
+    it "should still work with total_entries nil" do
+      page = Item.paginate(page: 3, total_entries: nil)
+      page.current_page.must_equal 3
+    end
+
+    it "should validate page number against auto-counted total_entries" do
+      lambda{ Item.paginate(page: 4, per_page: 10) }.must_raise Folio::InvalidPage
+    end
+
+    it "should work on associations" do
+      item = Item.first
+      12.times{ |i| item.related_things.create! }
+      page = item.related_things.paginate(page: 2, per_page: 10)
+      page.count.must_equal 2
+    end
+
+    it "should work when autocounting with string page/per_page" do
+      page = Item.paginate(page: "3", per_page: "10")
+      page.size.must_equal 4
+      page.total_entries.must_equal 24
+    end
+  end
+end

data/test/folio/will_paginate/collection_test.rb

@@ -0,0 +1,43 @@
+require 'minitest/autorun'
+require 'folio/will_paginate/collection'
+
+describe WillPaginate::Collection do
+  describe "create" do
+    it "should create an ordinal page" do
+      page = WillPaginate::Collection.create(1)
+      page.is_a?(Folio::Ordinal::Page).must_equal true
+    end
+
+    it "should set current_page on the created page" do
+      page = WillPaginate::Collection.create(4)
+      page.current_page.must_equal 4
+    end
+
+    it "should set per_page on the created page if given" do
+      page = WillPaginate::Collection.create(4, 10)
+      page.per_page.must_equal 10
+    end
+
+    it "should set total_entries on the created page if given" do
+      page = WillPaginate::Collection.create(4, 10, 50)
+      page.total_entries.must_equal 50
+    end
+
+    it "should yield the page to block if given" do
+      page = WillPaginate::Collection.create(1) { |p| p.replace [1, 2, 3] }
+      page.must_equal [1, 2, 3]
+    end
+
+    it "created page should have offset method like WillPaginate::Collection" do
+      page = WillPaginate::Collection.create(4, 10)
+      page.offset.must_equal 30
+    end
+
+    it "created should set total_entries on replace like WillPaginate::Collection" do
+      page = WillPaginate::Collection.create(4, 10)
+      page.total_entries.must_be_nil
+      page.replace [1, 2, 3]
+      page.total_entries.must_equal 33
+    end
+  end
+end

data/test/folio/will_paginate/view_helpers/link_renderer_test.rb

@@ -0,0 +1,160 @@
+require 'minitest/autorun'
+require 'folio/will_paginate/view_helpers/link_renderer'
+require 'folio/page'
+
+describe WillPaginate::LinkRenderer do
+  before do
+    @template = Class.new do
+      def link_to(*args)
+        "link_to(#{args.map(&:inspect).join(', ')})"
+      end
+
+      def content_tag(*args)
+        "content_tag(#{args.map(&:inspect).join(', ')})"
+      end
+
+      def will_paginate_translate(*args)
+        yield
+      end
+    end.new
+
+    @renderer = Class.new(WillPaginate::LinkRenderer) do
+      def url_for(page)
+        "url://#{page}"
+      end
+    end.new
+
+    # looks just like a standard WillPaginate collection would
+    @collection = Folio::Page.create
+    @collection.ordinal_pages = true
+    @collection.first_page = 1
+    @collection.total_entries = 200
+    @collection.per_page = 10
+    @collection.last_page = 20
+    @collection.current_page = 10
+    @collection.next_page = 11
+    @collection.previous_page = 9
+  end
+
+  it "should ignore page_links parameter with non-ordinal pages" do
+    @collection.ordinal_pages = false
+    @renderer.prepare(@collection, {page_links: true, previous_label: "Previous", next_label: "Next"}, @template)
+    @renderer.to_html.must_equal [
+      @template.link_to("Previous", "url://9", {:rel=>"prev", :class=>"prev_page"}),
+      @template.link_to("Next", "url://11", {:rel=>"next", :class=>"next_page"})
+    ].join
+  end
+
+  it "should still honor page_links parameter with ordinal pages" do
+    @renderer.prepare(@collection, {page_links: false, previous_label: "Previous", next_label: "Next"}, @template)
+    @renderer.to_html.must_equal [
+      @template.link_to("Previous", "url://9", {:rel=>"prev", :class=>"prev_page"}),
+      @template.link_to("Next", "url://11", {:rel=>"next", :class=>"next_page"})
+    ].join
+
+    @renderer.prepare(@collection, {page_links: true, previous_label: "Previous", next_label: "Next"}, @template)
+    @renderer.to_html.must_equal [
+      @template.link_to("Previous", "url://9", {:rel=>"prev", :class=>"prev_page"}),
+      @template.link_to("1", "url://1", {:rel=>"start", :class=>nil}),
+      @renderer.gap_marker,
+      @template.content_tag(:span, "10", {:class=>"current"}),
+      @renderer.gap_marker,
+      @template.link_to("20", "url://20", {:rel=>nil, :class=>nil}),
+      @template.link_to("Next", "url://11", {:rel=>"next", :class=>"next_page"})
+    ].join
+  end
+
+  it "should treat last_page as total_pages when known" do
+    @collection.last_page = 15
+    @renderer.prepare(@collection, {}, @template)
+    @renderer.total_pages.must_equal @collection.last_page
+  end
+
+  it "should treat next_page as total_pages when last_page unknown" do
+    @collection.last_page = nil
+    @renderer.prepare(@collection, {}, @template)
+    @renderer.total_pages.must_equal @collection.next_page
+  end
+
+  it "should add :gap after page links when last_page unknown" do
+    @collection.last_page = nil
+    @renderer.prepare(@collection, {page_links: true, previous_label: "Previous", next_label: "Next", inner_window: 1}, @template)
+    @renderer.to_html.must_equal [
+      @template.link_to("Previous", "url://9", {:rel=>"prev", :class=>"prev_page"}),
+      @template.link_to("1", "url://1", {:rel=>"start", :class=>nil}),
+      @renderer.gap_marker,
+      @template.link_to("9", "url://9", {:rel=>"prev", :class=>nil}),
+      @template.content_tag(:span, "10", {:class=>"current"}),
+      @template.link_to("11", "url://11", {:rel=>"next", :class=>nil}),
+      @renderer.gap_marker,
+      @template.link_to("Next", "url://11", {:rel=>"next", :class=>"next_page"})
+    ].join
+  end
+
+  it "should end inner window at next_page when last_page unknown" do
+    @collection.last_page = nil
+    @renderer.prepare(@collection, {page_links: true, previous_label: "Previous", next_label: "Next", inner_window: 2}, @template)
+    @renderer.to_html.must_equal [
+      @template.link_to("Previous", "url://9", {:rel=>"prev", :class=>"prev_page"}),
+      @template.link_to("1", "url://1", {:rel=>"start", :class=>nil}),
+      @renderer.gap_marker,
+      @template.link_to("7", "url://7", {:rel=>nil, :class=>nil}),
+      @template.link_to("8", "url://8", {:rel=>nil, :class=>nil}),
+      @template.link_to("9", "url://9", {:rel=>"prev", :class=>nil}),
+      @template.content_tag(:span, "10", {:class=>"current"}),
+      @template.link_to("11", "url://11", {:rel=>"next", :class=>nil}),
+      @renderer.gap_marker,
+      @template.link_to("Next", "url://11", {:rel=>"next", :class=>"next_page"})
+    ].join
+  end
+
+  describe "previous_page" do
+    it "should respect collection.previous_page" do
+      @collection.previous_page = 5
+      @renderer.prepare(@collection, {page_links: false, previous_label: "Previous", next_label: "Next"}, @template)
+      @renderer.to_html.must_equal [
+        @template.link_to("Previous", "url://5", {:rel=>"prev", :class=>"prev_page"}),
+        @template.link_to("Next", "url://11", {:rel=>"next", :class=>"next_page"})
+      ].join
+    end
+
+    it "should produce link with rel=prev for non-numeric" do
+      @collection.previous_page = "abcdef"
+      @renderer.prepare(@collection, {page_links: false, previous_label: "Previous", next_label: "Next"}, @template)
+      @renderer.to_html.must_equal [
+        @template.link_to("Previous", "url://abcdef", {:rel=>"prev", :class=>"prev_page"}),
+        @template.link_to("Next", "url://11", {:rel=>"next", :class=>"next_page"})
+      ].join
+    end
+
+    it "should have rel=start in the html for non-numeric value matching first_page" do
+      @collection.first_page = "abcdef"
+      @collection.previous_page = "abcdef"
+      @renderer.prepare(@collection, {page_links: false, previous_label: "Previous", next_label: "Next"}, @template)
+      @renderer.to_html.must_equal [
+        @template.link_to("Previous", "url://abcdef", {:rel=>"prev start", :class=>"prev_page"}),
+        @template.link_to("Next", "url://11", {:rel=>"next", :class=>"next_page"})
+      ].join
+    end
+  end
+
+  describe "next_page" do
+    it "should respect collection.next_page" do
+      @collection.next_page = 15
+      @renderer.prepare(@collection, {page_links: false, previous_label: "Previous", next_label: "Next"}, @template)
+      @renderer.to_html.must_equal [
+        @template.link_to("Previous", "url://9", {:rel=>"prev", :class=>"prev_page"}),
+        @template.link_to("Next", "url://15", {:rel=>"next", :class=>"next_page"})
+      ].join
+    end
+
+    it "should produce link with rel=next for non-numeric value" do
+      @collection.next_page = "abcdef"
+      @renderer.prepare(@collection, {page_links: false, previous_label: "Previous", next_label: "Next"}, @template)
+      @renderer.to_html.must_equal [
+        @template.link_to("Previous", "url://9", {:rel=>"prev", :class=>"prev_page"}),
+        @template.link_to("Next", "url://abcdef", {:rel=>"next", :class=>"next_page"})
+      ].join
+    end
+  end
+end

data/test/folio/will_paginate/view_helpers_test.rb

@@ -0,0 +1,49 @@
+require 'minitest/autorun'
+require 'folio/will_paginate/view_helpers'
+
+# for I18n in page_entries_info
+require 'active_support/core_ext/string/inflections'
+
+describe WillPaginate::ViewHelpers do
+  include WillPaginate::ViewHelpers
+
+  before do
+    @collection = Folio::Ordinal::Page.create
+  end
+
+  describe "will_paginate" do
+    before do
+      @renderer = Minitest::Mock.new
+      @renderer.expect(:prepare, nil, [@collection, Hash, self])
+      @renderer.expect(:to_html, '<PAGES>')
+    end
+
+    it "should return nil if total_pages is 1" do
+      @collection.total_entries = @collection.per_page
+      will_paginate(@collection, :renderer => @renderer).must_be_nil
+    end
+
+    it "should not error if total_entries is unknown" do
+      @collection.total_entries = nil
+      will_paginate(@collection, :renderer => @renderer).must_equal '<PAGES>'
+    end
+  end
+
+  describe "page_entries_info" do
+    it "should return nominally if collection is ordinal with total_entries known" do
+      @collection.total_entries = 20
+      page_entries_info(@collection).wont_be_nil
+    end
+
+    it "should return nil if total_entries is unknown" do
+      @collection.total_entries = nil
+      page_entries_info(@collection).must_be_nil
+    end
+
+    it "should return nil if collection is non-ordinal" do
+      @collection = Folio::Page.create
+      @collection.total_entries = 20
+      page_entries_info(@collection).must_be_nil
+    end
+  end
+end

data/test/folio_test.rb

@@ -0,0 +1,192 @@
+require 'minitest/autorun'
+require 'folio'
+
+describe Folio do
+  describe "class per_page" do
+    it "should have a per_page attribute" do
+      Folio.must_respond_to :per_page
+      Folio.must_respond_to :per_page=
+    end
+
+    it "should allow setting by per_page=" do
+      was = Folio.per_page
+      Folio.per_page = 100
+      Folio.per_page.must_equal 100
+      Folio.per_page = was
+    end
+
+    it "should allow setting by argument to per_page" do
+      was = Folio.per_page
+      Folio.per_page(100)
+      Folio.per_page.must_equal 100
+      Folio.per_page = was
+    end
+
+    it "should default to 30" do
+      Folio.per_page.must_equal 30
+    end
+  end
+
+  before do
+    page_klass = Class.new do
+      include Folio::Page
+    end
+
+    @klass = Class.new do
+      define_method :build_page do
+        page = page_klass.new
+        page.ordinal_pages = false
+        page.first_page = :first
+        page.last_page = :last
+        page
+      end
+
+      def fill_page(page)
+        page.next_page = :next
+        page.previous_page = :previous
+        page
+      end
+
+      include Folio
+    end
+
+    @folio = @klass.new
+  end
+
+  describe "paginate" do
+    it "should get the page from the folio's build_page method" do
+      page = @folio.paginate
+      page.ordinal_pages.must_equal false
+      page.first_page.must_equal :first
+      page.last_page.must_equal :last
+    end
+
+    it "should pass the page through the folio's fill_page method" do
+      page = @folio.paginate
+      page.next_page.must_equal :next
+      page.previous_page.must_equal :previous
+    end
+
+    it "should populate current_page and per_page before passing it to fill_page" do
+      @klass.send(:define_method, :fill_page) do |page|
+        page.current_page.wont_be_nil
+        page.per_page.wont_be_nil
+      end
+      @folio.paginate
+    end
+
+    describe "page parameter" do
+      it "should populate onto the page" do
+        page = @folio.paginate(page: :current)
+        page.current_page.must_equal :current
+      end
+
+      it "should default to the page's first_page" do
+        page = @folio.paginate
+        page.current_page.must_equal page.first_page
+      end
+
+      it "should set to the page's first_page if explicitly nil" do
+        page = @folio.paginate(page: nil)
+        page.current_page.must_equal page.first_page
+      end
+
+      it "should not set to the page's first_page if explicitly false" do
+        page = @folio.paginate(page: false)
+        page.current_page.must_equal false
+      end
+    end
+
+    describe "per_page parameter" do
+      it "should populate onto the page" do
+        page = @folio.paginate(per_page: 100)
+        page.per_page.must_equal 100
+      end
+
+      it "should default to the folio's per_page" do
+        @folio.per_page = 100
+        page = @folio.paginate
+        page.per_page.must_equal 100
+      end
+    end
+
+    describe "total_entries parameter" do
+      it "should populate onto the page" do
+        page = @folio.paginate(total_entries: 100)
+        page.total_entries.must_equal 100
+      end
+
+      it "should default to the nil if the folio does not implement count" do
+        page = @folio.paginate
+        page.total_entries.must_be_nil
+      end
+
+      it "should default to the result of count if the folio implements count" do
+        @klass.send(:define_method, :count) { 100 }
+        page = @folio.paginate
+        page.total_entries.must_equal 100
+      end
+
+      it "should not-execute the count if total_entries provided" do
+        called = false
+        @klass.send(:define_method, :count) { called = true }
+        @folio.paginate(total_entries: 100)
+        called.must_equal false
+      end
+
+      it "should not-execute the count if total_entries provided as nil" do
+        called = false
+        @klass.send(:define_method, :count) { called = true }
+        page = @folio.paginate(total_entries: nil)
+        called.must_equal false
+        page.total_entries.must_be_nil
+      end
+    end
+  end
+
+  describe "per_page class attribute" do
+    it "should exist" do
+      @klass.must_respond_to :per_page
+      @klass.must_respond_to :per_page=
+    end
+
+    it "should be settable from per_page=" do
+      @klass.per_page = 100
+      @klass.per_page.must_equal 100
+    end
+
+    it "should be settable from per_page with argument" do
+      @klass.per_page(100)
+      @klass.per_page.must_equal 100
+    end
+
+    it "should default to Folio.per_page" do
+      was = Folio.per_page
+      Folio.per_page = 50
+      @klass.per_page.must_equal 50
+      Folio.per_page = was
+    end
+  end
+
+  describe "per_page instance attribute" do
+    it "should exist" do
+      @folio.must_respond_to :per_page
+      @folio.must_respond_to :per_page=
+    end
+
+    it "should be settable from per_page=" do
+      @folio.per_page = 100
+      @folio.per_page.must_equal 100
+    end
+
+    it "should be settable from per_page with argument" do
+      @folio.per_page(100)
+      @folio.per_page.must_equal 100
+    end
+
+    it "should default to class' per_page" do
+      @klass.per_page = 50
+      @folio.per_page.must_equal 50
+    end
+  end
+end