simply_paginate 0.0.3 → 0.0.4

data/README.md

@@ -1,5 +1,5 @@
 # SimplyPaginate
-[![Build Status](https://travis-ci.org/guiman/simply_paginate.png)](https://travis-ci.org/guiman/simply_paginate)
+[![Build Status](https://travis-ci.org/guiman/simply_paginate.png)](https://travis-ci.org/guiman/simply_paginate) [![Code Climate](https://codeclimate.com/github/guiman/simply_paginate.png)](https://codeclimate.com/github/guiman/simply_paginate)
 
 Simply paginate will do just that, give me a collection and you will be able to use a pagination logic (no extra html boilerplate or dependecies).
 
@@ -19,60 +19,79 @@ Or install it yourself as:
 
 ## Motivation
 When dealing with pagination most known gems come bundled with lots of extra functionality I usually don't need (like html boilerplate), this is my attempt to create just the pagination logic, as simple as that.
+So if you need pagiation but don't want to reinvent the wheel and keep your collections Pagination Agnostic, this is the gem you need. The only
+requirement is the adoption of the popular ruby Enumerable interface.
 
 ## Usage
 
 ```ruby
 require 'simply_paginate'
 
-collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+include SimplyPaginate
 
-paginator = SimplyPaginate::Paginator.new(collection)
+collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
-# create pages with max of 3 elements
-SimplyPaginate::Paginator.per_page 3
+pages = Paginator.new(collection, 3)
 
 # retrieve a certain page
-paginator[0]
+pages[1]
 
 #move through the pages freely
-paginator[0].next
-paginator[0].previous
+pages[1].next
+pages[1].previous
 
 #you might want the first element on the 3rd page
-paginator[0].next.next.next.previous.elements[0]
+pages[1].next.next.next.previous.elements[0]
 
 #or maybe all of them
-paginator[0].next.next.next.previous.elements
-```
+pages[0].next.next.next.previous.elements
 
-There is also the possibility to use a DataMapper::Collection as the collection to be paginated (right out of the box, not extensions needed):
-
-```ruby
-# I will guess you have a model called Post
-# By default Paginator.per_page is 10
+#you can also iterate the ruby way
+pages.each do |page|
+  puts page.elements
+end
 
-paginator = SimplyPaginate::Paginator.new(Post.all)
+#or in a more old fashion way
+pages.start
 
-paginator[0].elements # this will return a DataMapper::Collection with the first 10 elements
+while pages.next? do
+  puts pages.current.elements
+  
+  pages.next!
+end
 ```
 
-## Currently working on:
+## Changes on this branch
+Well this branch introduced a better design about the relationship between pages and page, and also
+an improvement on the API.
 
-* Adding support for common ORMs like: ActiveRecord, Sequel and DataMapper.
-* Testing...
+Now a Page can be used without the need of having a Paginator, and also a Paginator could be transversed
+without need to access pages directly.
 
-## Alternative branch
-This branch contains a different implementation on the paging algorithm. This one creates pages on the fly and calculating offsets,
-so when you call ```previous``` or ```next``` or ```[]```page object representing is created on that moment, thus saving memory.
+```ruby
+require 'simply_paginate'
 
-Another modification is that the ```per_page``` value has moved up to the class, and there is no need on calling ```paginate``` anymore,
-also the ```pages``` has been dropped.
+include SimplyPaginate
 
-## Release 0.0.2 features:
-* Dropping the each_slice in order to use a more memory efficient index algorithm for paging.
-* Adding more tests to the page object.
+collection = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
+# Give me the first page of the collection with a size of 3
+first_page = Page.new(1, collection, 3)
+
+first_page.elements
+#=> [1, 2, 3]
+first_page.next.elements
+#=> [4, 5, 6]
+```
+##0.0.4 - Changelog:
+
+* Redesign on relation between paginator and pages. You can use them togheter or separately.
+* Improved API for Paginator, now including:
+  * each iteration
+  * next!, next?, current and start methods for manual iteration
+  * first and last accessors
+* Test improvement
+ 
 ## Contributing
 
 1. Fork it

data/examples/data_mapper_example/Gemfile

@@ -0,0 +1,7 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gem 'simply_paginate', github: 'guiman/simply_paginate'
+gem 'data_mapper'
+gem 'dm-sqlite-adapter'
+

data/examples/data_mapper_example/test.rb

@@ -0,0 +1,19 @@
+require 'bundler'
+Bundler.require
+
+DataMapper.setup :default, 'sqlite::memory:'
+
+class Person
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :age, String
+end
+
+DataMapper.auto_migrate!
+
+100.times { Person.create age: rand(1..90) }
+
+paginator = SimplyPaginate::Paginator.new(Person.all)
+
+paginator[0].elements.all(:age.gt => 10)

data/lib/simply_paginate/page.rb

@@ -1,33 +1,35 @@
 module SimplyPaginate
   class Page
-    attr_reader :first, :last
+    attr_reader :index, :collection, :size
 
-    def initialize(first, last, paginator, previous_page = nil, next_page = nil)
-      @first = first
-      @last = last
-      @paginator = paginator
+    def initialize(page, collection, size = Paginator.per_page)
+      @index = page
+      @collection = collection
+      @size = size
+
+      @move_page = lambda do |number|
+        new_index = @index + number
+        Page.new(new_index, @collection, @size) unless (new_index == 0) || (new_index > (@collection.count.to_f / @size.to_f).ceil)
+      end
     end
 
     def next
-      first = @last + 1
-      last = first + Paginator.per_page - 1
-
-      (first >= @paginator.collection.count) ? nil : @paginator.current = Page.new(first, last, @paginator)
+      @move_page.call(1)
     end
 
     def previous
-      first = @first - Paginator.per_page
-      last = @first - 1
-
-      (first < 0) ? nil : @paginator.current = Page.new(first, last, @paginator)
+      @move_page.call(-1)
     end
 
-    def current?
-      !@paginator.current.nil? && @paginator.current.first == @first && @paginator.current.last == @last
+    def elements
+      first = (@index - 1) * @size
+      last = first + size - 1
+
+      collection[first..last]
     end
 
-    def elements
-      @paginator.collection[@first..@last]
+    def ==(other)
+      (index == other.index) && (elements == other.elements) if other.respond_to?(:index) && other.respond_to?(:elements)
     end
   end
 end

data/lib/simply_paginate/paginator.rb

@@ -1,7 +1,8 @@
 module SimplyPaginate
+  FIRST_PAGE_INDEX = 1
+
   class Paginator
     attr_reader :collection
-    attr_accessor :current
 
     def self.per_page=(amount_per_page)
       raise NotInRangeError.new("Amount per page should be greater than 0") unless amount_per_page > 0
@@ -13,20 +14,56 @@ module SimplyPaginate
       @@per_page
     end
 
-    def initialize(collection)
+    def initialize(collection, per_page = self.class.per_page)
       @collection = collection
-      @current = nil
+      @per_page = per_page
     end
 
-    def [](pos)
-      first = pos * @@per_page
-      last = first + @@per_page - 1
+    ## Basic Operations
 
-      ((first < 0) || (first >= self.collection.count)) ? nil : Page.new(first, last, self)
+    def first
+      self[FIRST_PAGE_INDEX]
+    end
+
+    def last
+      self[total_pages]
     end
 
     def total_pages
-      (@collection.count.to_f / @@per_page.to_f).ceil
+      (@collection.count.to_f / @per_page.to_f).ceil
+    end
+
+    def [](pos)
+      Page.new(pos, @collection) unless pos == 0 || pos > total_pages
+    end
+
+    ## Iteration
+
+    def next!
+      raise NoMethodError.new("You need to start before iterating") unless @current
+      @current = @current.next
+    end
+
+    def next?
+      @current != nil
+    end
+
+    def start
+      @current = first
+    end
+
+    def current
+      @current
+    end
+
+    def each
+      start
+
+      while next? do
+        yield current
+
+        next!
+      end
     end
 
     Paginator.per_page = 10

data/lib/simply_paginate/version.rb

@@ -1,3 +1,3 @@
 module SimplyPaginate
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/page_spec.rb

@@ -1,74 +1,39 @@
 require 'spec_helper'
 
-describe SimplyPaginate::Page do
-  before do
-    SimplyPaginate::Paginator.per_page = 5
+include SimplyPaginate
 
-    @paginator = SimplyPaginate::Paginator.new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
-    @first_page = SimplyPaginate::Page.new(0, 4, @paginator)
-    @last_page = SimplyPaginate::Page.new(5, 9, @paginator)
+describe Page do
+  include Helpers
 
-    class SimplyPaginate::Page
-      def paginator
-        @paginator
-      end
-    end
-  end
-
-  it "must always have an instance of paginator" do
-    @first_page.paginator.wont_be_nil
-    @last_page.paginator.wont_be_nil
+  let(:first_page) { build_page 1 }
 
-    @first_page.next.paginator.wont_be_nil
-    @first_page.next.previous.paginator.wont_be_nil
-  end
+  let(:second_page) { build_page 2 }
 
-  it "must be able to get the elements" do
-    @first_page.elements.must_equal [1, 2, 3, 4, 5]
-    @last_page.elements.must_equal [6, 7, 8, 9, 10]
+  let(:last_page) { build_page 4 }
 
-    @first_page.next.elements.must_equal [6, 7, 8, 9, 10]
-    @last_page.previous.elements.must_equal [1, 2, 3, 4, 5]
+  it "must represent a specific page on a collection" do
+    first_page.elements.must_equal [1, 2, 3]
+    first_page.index.must_equal SimplyPaginate::FIRST_PAGE_INDEX
   end
 
-  describe "when having next and previous pages" do
-    before do
-      SimplyPaginate::Paginator.per_page = 2
-    end
-
-    it "must be able to go back and foward" do
-      @paginator[1].next.elements.must_equal @paginator[2].elements
-      @paginator[1].previous.elements.must_equal @paginator[0].elements
-    end
+  it "must be able to retrieve it's elements" do
+    first_page.elements.must_equal [1, 2, 3]
   end
 
-  describe "when having previous and no next" do
-    it "must be able to go back " do
-      @last_page.next.must_be_nil
-      @last_page.previous.elements.must_equal @first_page.elements
-    end
+  it "must be able to compare with other page" do
+    first_page.must_equal first_page
+    first_page.wont_equal second_page
+    first_page.wont_equal Page.new(1, page_array_collection, 5)
+    first_page.must_equal Page.new(1, [1, 2, 3], 3)
   end
 
-  describe "when having next and no previous" do
-    it "must be able to go back " do
-      @first_page.next.elements.must_equal @last_page.elements
-      @first_page.previous.must_be_nil
-    end
+  it "must be able to move forward" do
+    first_page.next.must_equal second_page
+    last_page.next.must_be_nil
   end
 
-  describe "when moving to previous or next" do
-    it "must be setted as current when landed after next" do
-      @paginator[0].next
-      @paginator[0].current?.must_equal false
-      @paginator[1].current?.must_equal true
-    end
-
-    it "must be setted as current when landed after previous" do
-      @paginator[1].previous
-      @paginator[1].current?.must_equal false
-      @paginator[0].current?.must_equal true
-    end
-
+  it "must be able to move backwards" do
+    first_page.previous.must_be_nil
+    second_page.previous.must_equal first_page
   end
-
 end

data/spec/paginator_spec.rb

@@ -1,50 +1,77 @@
 require 'spec_helper'
 
+Paginator.per_page = 3
 
-describe SimplyPaginate::Paginator do
-  before do
-    SimplyPaginate::Paginator.per_page = 3
-    @paginator = SimplyPaginate::Paginator.new [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-  end
+describe Paginator do
+  include Helpers
+
+  let(:pages) { Paginator.new page_array_collection }
+
+  let(:first_page) { build_page 1 }
+
+  let(:last_page) { build_page 4 }
 
-  describe 'before paginating' do
-    it 'must be able to paginate' do
-      @paginator.total_pages.must_equal 4
+  it "must be able to iterate using each" do
+    count = 0
+    results = []
+
+    pages.each do |page|
+      page.wont_be_nil
+      results << page.elements
+
+      count += 1
     end
+
+    count.must_equal 4
+    results.must_equal [[1,2,3], [4,5,6], [7,8,9], [10]]
   end
 
-  describe 'after paginating' do
-    before do
-      SimplyPaginate::Paginator.per_page = 5
+  it "must be able to tell how many pages there are" do
+    pages.total_pages.must_equal 4
+  end
 
-      @first_page = SimplyPaginate::Page.new(0, 4, @paginator)
-      @last_page = SimplyPaginate::Page.new(5, 9, @paginator)
+  it "must be able to retrieve a certain page" do
+    pages[0].must_be_nil
+    pages[1].wont_be_nil
+    pages[1].must_equal first_page
+    pages[4].must_equal last_page
+    pages[5].must_be_nil
+  end
 
-      @pages = [@first_page, @last_page]
-    end
+  it "must be able to retrieve the first page" do
+    pages.first.must_equal first_page
+  end
 
-    it 'must be able to paginate' do
-      @paginator.total_pages.must_equal 2
-    end
+  it "must be able to retrieve the last page" do
+    pages.last.must_equal pages[4]
+  end
 
-    it 'must be able to retrieve a certain page' do
-      @paginator[0].elements.must_equal @first_page.elements
-      @paginator[0].previous.must_be_nil
-      @paginator[0].next.wont_be_nil
+  describe "when iterating using 'start', 'next!' and 'next?'" do
+    it "must need to start before moving to the next " do
+      lambda { pages.next! }.must_raise NoMethodError
     end
 
-    it 'must be able to retrieve all pages' do
-      @paginator.total_pages.must_equal 2
+    it "must move to the next page using 'next!'" do
+      iteration_pages = pages
+      iteration_pages.start
+      iteration_pages.next!
+      iteration_pages.current.must_equal build_page(2)
+    end
 
-      #test first element
-      @paginator[0].elements.must_equal @first_page.elements
-      @paginator[0].previous.must_be_nil
-      @paginator[0].next.wont_be_nil
+    it "must retrieve the current page using 'current'" do
+      iteration_pages = pages
+      iteration_pages.current.must_be_nil
+      iteration_pages.start
+      iteration_pages.current.must_equal first_page
+    end
 
-      #test second element
-      @paginator[1].elements.must_equal @last_page.elements
-      @paginator[1].previous.wont_be_nil
-      @paginator[1].next.must_be_nil
+    it "must retrieve if we can get a next value using 'next?'" do
+      iteration_pages = pages
+      iteration_pages.next?.must_equal false
+      iteration_pages.start
+      iteration_pages.next?.must_equal true
+      4.times { iteration_pages.next! }
+      iteration_pages.next?.must_equal false
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,13 @@
 require 'bundler'
 require 'minitest/autorun'
 Bundler.require
+
+module Helpers
+  def page_array_collection
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  end
+
+  def build_page(number)
+    lambda { Page.new number, page_array_collection, 3 }.call
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simply_paginate
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-25 00:00:00.000000000 Z
+date: 2013-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,6 +72,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/data_mapper_example/Gemfile
+- examples/data_mapper_example/test.rb
 - lib/simply_paginate.rb
 - lib/simply_paginate/not_in_range_error.rb
 - lib/simply_paginate/page.rb