datapage 0.0.1

data/ChangeLog

@@ -0,0 +1,2 @@
+0.0.1 Thu Aug 25 14:10:55 BST 2011
+	* initial release

data/README.rd

@@ -0,0 +1,122 @@
+=begin
+index:Ej
+
+= Data/Page: Help when paging through sets of results
+
+Last Modified: 2005-05-22 00:28:04
+
+--
+
+When searching through large amounts of data, it is often the case
+that a result set is returned that is larger than we want to display
+on one page. This results in wanting to page through various pages of
+data. The maths behind this is unfortunately fiddly, hence this
+module.
+
+The main concept is that you pass in the number of total entries, the
+number of entries per page, and the current page number. You can then
+call methods to find out how many pages of information there are, and
+what number the first and last entries on the current page really are.
+
+For example, say we wished to page through the integers from 1 to 100
+with 20 entries per page. The first page would consist of 1-20, the
+second page from 21-40, the third page from 41-60, the fourth page
+from 61-80 and the fifth page from 81-100. This module would help you
+work this out.
+
+== Examples
+
+  require "datapage"
+
+  page = Data::Page.new()
+  page.total_entries(total_entries)
+  page.entries_per_page(entries_per_page)
+  page.current_page(current_page)
+
+  puts "         First page: #{page.first_page}"
+  puts "          Last page: #{page.last_page}"
+  puts "First entry on page: #{page.first}"
+  puts " Last entry on page: #{page.last}"
+
+== API
+
+--- Data::Page#new ()
+    This is the constructor, which takes no arguments.
+        page = Data::Page.new()
+
+--- Data::Page#total_entries
+    This method get or sets the total number of entries:
+       puts "Entries: #{page.total_entries}"
+
+--- Data::Page#entries_per_page
+    This method get or sets the total number of entries
+    per page (which defaults to 10):
+       puts "Per page: #{page.entries_per_page}"
+
+--- Data::Page#current_page
+    This method gets or sets the current page number
+    (which defaults to 1):
+       puts "Page: #{page.current_page}"
+
+--- Data::Page#entries_on_this_page
+    This methods returns the number of entries on the current page:
+       puts "There are #{page.entries_on_this_page} entries displayed"
+
+--- Data::Page#first_page
+    This method returns the first page. This is put in for reasons of
+    symmetry with last_page, as it always returns 1:
+       puts "Pages range from: #{page.first_page}"
+
+--- Data::Page#last_page
+    This method returns the total number of pages of information:
+       puts "Pages range to: #{page.last_page}"
+
+--- Data::Page#first
+    This method returns the number of the first entry on the current page:
+       puts "Showing entries from: #{page.first}"
+
+--- Data::Page#last
+    This method returns the number of the last entry on the current page:
+       puts "Showing entries to: #{page.last}"
+
+--- Data::Page#previous_page
+    This method returns the previous page number, if one exists. Otherwise
+    it returns nil:
+       puts "Previous page number: #{page.previous_page}" if page.previous_page
+
+--- Data::Page#next_page
+    This method returns the next page number, if one exists. Otherwise
+    it returns nil:
+       puts "Next page number: #{page.next_page}" if page.next_page
+
+--- Data::Page#splice( array )
+    This method takes in a array, and returns only the values which are
+    on the current page:
+       visible_holidays = page.splice(holidays);
+
+--- Data::Page#skipped
+    This method is useful paging through data in a database using SQL
+    LIMIT clauses. It is simply page.first - 1:
+
+--- Data::Page#change_entries_per_page
+    This method changes the number of entries per page and the
+    current page number such that the *first* item on the current
+    page will be present on the new page:
+        page.total_entries(50);
+        page.entries_per_page(20);
+        page.current_page(3);
+        puts page->first; # 41
+        page.change_entries_per_page(30);
+        puts page.current_page; # 2 - the page that item 41 will show in
+
+== Notes
+
+It has been said before that this code is "too simple" for distribution, but I
+must disagree. I have seen people write this kind of code over and
+over again and they always get it wrong. Perhaps now they will spend
+more time getting the rest of their code right...
+
+--
+
+- ((<Leon Brocard|URL:http://www.astray.com/>)) -
+=end

data/Rakefile

@@ -0,0 +1,8 @@
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/simple.rb'
+  test.verbose = true
+end

data/datapage.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name        = "datapage"
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Leon Brocard"]
+  s.email       = ["acme@astray.com"]
+  s.homepage    = "http://github.com/acme/ruby-data-page/"
+  s.summary     = "Data::Page helps when paging through sets of results"
+  s.description = "Data::Page helps when paging through sets of results"
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_development_dependency "rake", ">= 0"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+
+  s.rdoc_options = ["--charset=UTF-8"]
+end

data/lib/datapage.rb

@@ -0,0 +1,92 @@
+class Data::Page
+  attr_reader :total_entries, :entries_per_page, :current_page
+  def initialize(total_entries=0, entries_per_page=10, current_page=1)
+    @total_entries, @entries_per_page, @current_page = total_entries, entries_per_page, current_page
+  end
+  def total_entries(*total_entries)
+    @total_entries = total_entries[0] if total_entries[0]
+    return @total_entries
+  end
+  def entries_per_page(*entries_per_page)
+    @entries_per_page = entries_per_page[0] if entries_per_page[0]
+    return @entries_per_page
+  end
+  def current_page(*current_page)
+    @current_page = current_page[0] if current_page[0]
+    return @current_page
+  end
+  def first_page
+    return 1
+  end
+  def last_page
+    pages = @total_entries.to_f / @entries_per_page.to_f
+    if pages == pages.floor
+        last_page = pages
+    else
+        last_page = 1 + pages.floor
+    end
+    if last_page < 1
+        last_page = 1
+    end
+    return last_page
+  end
+  def first
+    if @total_entries == 0
+        return 0
+    else
+        return ( ( @current_page - 1 ) * @entries_per_page ) + 1
+    end
+  end
+  def last
+    if @current_page == self.last_page
+        return @total_entries
+    else
+        return @current_page * @entries_per_page
+    end
+  end
+  def previous_page
+    if @current_page > 1
+        return @current_page - 1
+    else
+        return nil
+    end
+  end
+  def next_page
+    if @current_page < self.last_page
+        return @current_page + 1
+    else
+        return nil
+    end
+  end
+  def splice(array)
+    if array.length > self.last
+        top = self.last
+    else
+        top = array.length
+    end
+    if top == 0
+        return []
+    end
+    return array.slice(self.first-1, self.last - self.first + 1)
+  end
+  def skipped
+    skipped = self.first - 1
+    if skipped < 0
+        return 0
+    else
+        return skipped
+    end
+  end
+  def entries_on_this_page
+    if @total_entries == 0
+        return 0
+    else
+        return self.last - self.first + 1
+    end
+  end
+  def change_entries_per_page(new_epp)
+    new_page = 1 + (self.first / new_epp)
+    self.entries_per_page(new_epp)
+    self.current_page(new_page)
+  end
+end

data/test/simple.rb

@@ -0,0 +1,123 @@
+require "datapage"
+require "test/unit"
+
+class TestSimpleNumber < Test::Unit::TestCase
+ 
+  def test_simple_1
+    text = "# Initial test
+50 10 1    1 5 1 10 undef 1 2 0,1,2,3,4,5,6,7,8,9            10    15 1
+50 10 2    1 5 11 20 1 2 3 10,11,12,13,14,15,16,17,18,19     10    15 1
+50 10 3    1 5 21 30 2 3 4 20,21,22,23,24,25,26,27,28,29     10    15 2
+50 10 4    1 5 31 40 3 4 5 30,31,32,33,34,35,36,37,38,39     10    15 3
+50 10 5    1 5 41 50 4 5 undef 40,41,42,43,44,45,46,47,48,49 10    15 3
+
+# Under 10
+1 10 1    1 1 1 1 undef 1 undef 0                     1    15 1
+2 10 1    1 1 1 2 undef 1 undef 0,1                   2    15 1
+3 10 1    1 1 1 3 undef 1 undef 0,1,2                 3    15 1
+4 10 1    1 1 1 4 undef 1 undef 0,1,2,3               4    15 1
+5 10 1    1 1 1 5 undef 1 undef 0,1,2,3,4             5    15 1
+6 10 1    1 1 1 6 undef 1 undef 0,1,2,3,4,5           6    15 1
+7 10 1    1 1 1 7 undef 1 undef 0,1,2,3,4,5,6         7    15 1
+8 10 1    1 1 1 8 undef 1 undef 0,1,2,3,4,5,6,7       8    15 1
+9 10 1    1 1 1 9 undef 1 undef 0,1,2,3,4,5,6,7,8     9    15 1
+10 10 1   1 1 1 10 undef 1 undef 0,1,2,3,4,5,6,7,8,9  10   15 1
+
+# Over 10
+11 10 1    1 2 1 10 undef 1 2 0,1,2,3,4,5,6,7,8,9     10   10 1
+11 10 2    1 2 11 11 1 2 undef 10                     1    10 2
+12 10 1    1 2 1 10 undef 1 2 0,1,2,3,4,5,6,7,8,9     10   10 1
+12 10 2    1 2 11 12 1 2 undef 10,11                  2    10 2
+13 10 1    1 2 1 10 undef 1 2 0,1,2,3,4,5,6,7,8,9     10   10 1
+13 10 2    1 2 11 13 1 2 undef 10,11,12               3    10 2
+
+# Under 20
+19 10 1    1 2 1 10 undef 1 2 0,1,2,3,4,5,6,7,8,9            10   4 1
+19 10 2    1 2 11 19 1 2 undef 10,11,12,13,14,15,16,17,18    9    4 3
+20 10 1    1 2 1 10 undef 1 2 0,1,2,3,4,5,6,7,8,9            10   4 1
+20 10 2    1 2 11 20 1 2 undef 10,11,12,13,14,15,16,17,18,19 10   4 3
+
+# Over 20
+21 10 1    1 3 1 10 undef 1 2 0,1,2,3,4,5,6,7,8,9        10   19 1
+21 10 2    1 3 11 20 1 2 3 10,11,12,13,14,15,16,17,18,19 10   19 1
+21 10 3    1 3 21 21 2 3 undef 20                        1    19 2
+22 10 1    1 3 1 10 undef 1 2 0,1,2,3,4,5,6,7,8,9        10   19 1
+22 10 2    1 3 11 20 1 2 3 10,11,12,13,14,15,16,17,18,19 10   19 1
+22 10 3    1 3 21 22 2 3 undef 20,21                     2    19 2
+23 10 1    1 3 1 10 undef 1 2 0,1,2,3,4,5,6,7,8,9        10   19 1
+23 10 2    1 3 11 20 1 2 3 10,11,12,13,14,15,16,17,18,19 10   19 1
+23 10 3    1 3 21 23 2 3 undef 20,21,22                  3    19 2
+
+# Zero test
+0 10 1    1 1 0 0 undef 1 undef '' 0    5 1
+"
+    lines = text.split("\n");
+    lines.each do |line|
+      next if line.length == 0
+      if line.match(/^# ?(.+)/)
+        name = $1
+        # puts "name is #{name}"
+        next
+      end
+      # puts "[#{line}]"
+      vals = line.split(/\s+/).collect! {|x|
+        if x.match(/^undef$/)
+          nil
+        elsif x.match(/^''$/)
+          ''
+        elsif x.match(/^\d+$/)
+          x.to_i
+        else
+          x
+        end
+      }
+      # puts vals.inspect
+      oldpage = Data::Page.new(vals[0].to_i, vals[1].to_i, vals[2].to_i)
+      self._check(oldpage, name, vals);
+      newpage = Data::Page.new()
+      newpage.total_entries(vals[0].to_i)
+      newpage.entries_per_page(vals[1].to_i)
+      newpage.current_page(vals[2].to_i)
+      self._check(newpage, name, vals);
+    end
+    page = Data::Page.new(100, 10, 1)
+    assert_equal(page.total_entries, 100)
+    assert_equal(page.entries_per_page, 10)
+    assert_equal(page.current_page, 1)
+    assert_equal(page.first_page, 1)
+    assert_equal(page.last_page, 10)
+    assert_equal(page.first, 1)
+    assert_equal(page.last, 10)
+    assert_equal(page.previous_page, nil)
+    assert_equal(page.next_page, 2)
+    assert_equal(page.splice([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]), [1,2,3,4,5,6,7,8,9,10])
+    assert_equal(page.skipped, 0)
+    assert_equal(page.entries_on_this_page, 10)
+  end
+  def _check(page, name, vals)
+    # puts "check #{page.total_entries} total_entries, #{page.entries_per_page} entries_per_page, #{page.current_page} current_page"
+    assert_instance_of(Data::Page, page)
+    assert_equal(page.first_page, vals[3])
+    assert_equal(page.last_page, vals[4])
+    assert_equal(page.first, vals[5])
+    assert_equal(page.last, vals[6])
+    assert_equal(page.previous_page, vals[7])
+    assert_equal(page.current_page, vals[8])
+    assert_equal(page.next_page, vals[9])
+    
+    integers = (0..vals[0]-1).to_a
+    integers = page.splice(integers)
+    integers = integers.join(',')
+    assert_equal(integers, vals[10].to_s)
+
+    assert_equal( page.entries_on_this_page, vals[11])
+
+    skipped = vals[5] - 1
+    skipped = 0 if skipped < 0
+    assert_equal(page.skipped, skipped );
+    page.change_entries_per_page( vals[12] );
+    assert_equal( page.current_page, vals[13] );
+  end
+end
+
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: datapage
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Leon Brocard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-25 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Data::Page helps when paging through sets of results
+email: 
+- acme@astray.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- ChangeLog
+- README.rd
+- Rakefile
+- datapage.gemspec
+- lib/datapage.rb
+- test/simple.rb
+has_rdoc: true
+homepage: http://github.com/acme/ruby-data-page/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Data::Page helps when paging through sets of results
+test_files: []
+