pagify 0.6.1

data/tasks/spec.rake

@@ -0,0 +1,54 @@
+
+if HAVE_SPEC_RAKE_SPECTASK and not PROJ.spec.files.to_a.empty?
+require 'spec/rake/verify_rcov'
+
+namespace :spec do
+
+  desc 'Run all specs with basic output'
+  Spec::Rake::SpecTask.new(:run) do |t|
+    t.ruby_opts = PROJ.ruby_opts
+    t.spec_opts = PROJ.spec.opts
+    t.spec_files = PROJ.spec.files
+    t.libs += PROJ.libs
+  end
+
+  desc 'Run all specs with text output'
+  Spec::Rake::SpecTask.new(:specdoc) do |t|
+    t.ruby_opts = PROJ.ruby_opts
+    t.spec_opts = PROJ.spec.opts + ['--format', 'specdoc']
+    t.spec_files = PROJ.spec.files
+    t.libs += PROJ.libs
+  end
+
+  if HAVE_RCOV
+    desc 'Run all specs with RCov'
+    Spec::Rake::SpecTask.new(:rcov) do |t|
+      t.ruby_opts = PROJ.ruby_opts
+      t.spec_opts = PROJ.spec.opts
+      t.spec_files = PROJ.spec.files
+      t.libs += PROJ.libs
+      t.rcov = true
+      t.rcov_dir = PROJ.rcov.dir
+      t.rcov_opts = PROJ.rcov.opts + ['--exclude', 'spec']
+    end
+
+    RCov::VerifyTask.new(:verify) do |t| 
+      t.threshold = PROJ.rcov.threshold
+      t.index_html = File.join(PROJ.rcov.dir, 'index.html')
+      t.require_exact_threshold = PROJ.rcov.threshold_exact
+    end
+
+    task :verify => :rcov
+    remove_desc_for_task %w(spec:clobber_rcov)
+  end
+
+end  # namespace :spec
+
+desc 'Alias to spec:run'
+task :spec => 'spec:run'
+
+task :clobber => 'spec:clobber_rcov' if HAVE_RCOV
+
+end  # if HAVE_SPEC_RAKE_SPECTASK
+
+# EOF

data/tasks/svn.rake

@@ -0,0 +1,47 @@
+
+if HAVE_SVN
+
+unless PROJ.svn.root
+  info = %x/svn info ./
+  m = %r/^Repository Root:\s+(.*)$/.match(info)
+  PROJ.svn.root = (m.nil? ? '' : m[1])
+end
+PROJ.svn.root = File.join(PROJ.svn.root, PROJ.svn.path) unless PROJ.svn.path.empty?
+
+namespace :svn do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  desc 'Show tags from the SVN repository'
+  task :show_tags => 'svn:prereqs' do |t|
+    tags = %x/svn list #{File.join(PROJ.svn.root, PROJ.svn.tags)}/
+    tags.gsub!(%r/\/$/, '')
+    tags = tags.split("\n").sort {|a,b| b <=> a}
+    puts tags
+  end
+
+  desc 'Create a new tag in the SVN repository'
+  task :create_tag => 'svn:prereqs' do |t|
+    v = ENV['VERSION'] or abort 'Must supply VERSION=x.y.z'
+    abort "Versions don't match #{v} vs #{PROJ.version}" if v != PROJ.version
+
+    svn = PROJ.svn
+    trunk = File.join(svn.root, svn.trunk)
+    tag = "%s-%s" % [PROJ.name, PROJ.version]
+    tag = File.join(svn.root, svn.tags, tag)
+    msg = "Creating tag for #{PROJ.name} version #{PROJ.version}"
+
+    puts "Creating SVN tag '#{tag}'"
+    unless system "svn cp -m '#{msg}' #{trunk} #{tag}"
+      abort "Tag creation failed" 
+    end
+  end
+
+end  # namespace :svn
+
+task 'gem:release' => 'svn:create_tag'
+
+end  # if PROJ.svn.path
+
+# EOF

data/tasks/test.rake

@@ -0,0 +1,40 @@
+
+if test(?e, PROJ.test.file) or not PROJ.test.files.to_a.empty?
+require 'rake/testtask'
+
+namespace :test do
+
+  Rake::TestTask.new(:run) do |t|
+    t.libs = PROJ.libs
+    t.test_files = if test(?f, PROJ.test.file) then [PROJ.test.file]
+                   else PROJ.test.files end
+    t.ruby_opts += PROJ.ruby_opts
+    t.ruby_opts += PROJ.test.opts
+  end
+
+  if HAVE_RCOV
+    desc 'Run rcov on the unit tests'
+    task :rcov => :clobber_rcov do
+      opts = PROJ.rcov.opts.dup << '-o' << PROJ.rcov.dir
+      opts = opts.join(' ')
+      files = if test(?f, PROJ.test.file) then [PROJ.test.file]
+              else PROJ.test.files end
+      files = files.join(' ')
+      sh "#{RCOV} #{files} #{opts}"
+    end
+
+    task :clobber_rcov do
+      rm_r 'coverage' rescue nil
+    end
+  end
+
+end  # namespace :test
+
+desc 'Alias to test:run'
+task :test => 'test:run'
+
+task :clobber => 'test:clobber_rcov' if HAVE_RCOV
+
+end
+
+# EOF

data/tasks/zentest.rake

@@ -0,0 +1,36 @@
+if HAVE_ZENTEST
+
+# --------------------------------------------------------------------------
+if test(?e, PROJ.test.file) or not PROJ.test.files.to_a.empty?
+require 'autotest'
+
+namespace :test do
+  task :autotest do
+    Autotest.run
+  end
+end
+
+desc "Run the autotest loop"
+task :autotest => 'test:autotest'
+
+end  # if test
+
+# --------------------------------------------------------------------------
+if HAVE_SPEC_RAKE_SPECTASK and not PROJ.spec.files.to_a.empty?
+require 'autotest/rspec'
+
+namespace :spec do
+  task :autotest do
+    load '.autotest' if test(?f, '.autotest')
+    Autotest::Rspec.run
+  end
+end
+
+desc "Run the autotest loop"
+task :autotest => 'spec:autotest'
+
+end  # if rspec
+
+end  # if HAVE_ZENTEST
+
+# EOF

data/test/helper.rb

@@ -0,0 +1,26 @@
+
+require 'rubygems'
+
+TestCase = begin
+             require 'minitest/unit'
+             MiniTest::Unit.autorun
+             MiniTest::Unit::TestCase
+           rescue LoadError
+             require 'test/unit'
+             Test::Unit::TestCase
+           end
+
+require 'pagify'
+#gem 'dm-core', '<0.10'
+#gem 'dm-aggregates', '<0.10'
+require 'dm-core'
+require 'dm-aggregates'
+require 'active_record'
+
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('1.8.7')
+  class Symbol
+    def to_proc
+      lambda{ |*args| args.shift.__send__(self, *args) }
+    end
+  end
+end

data/test/helper_model.rb

@@ -0,0 +1,83 @@
+
+module SuiteForModel
+
+  def test_page_correctness_fixnum
+    page_correctness 1
+  end
+
+  def test_page_correctness_string
+    page_correctness '1'
+  end
+
+  def test_nil_page_default_page_1
+    users = send(:User).pagify :page => nil, :per_page => 2
+    assert_equal 2, users.pager.size
+    assert_equal 1, users.page
+  end
+
+  def page_correctness page
+    users = send(:User).pagify :page => page, :per_page => 2
+
+    assert_equal 2, users.pager.size
+    assert_equal 1, users.page
+    assert_equal send(:User).first, users.first
+    assert_equal 2, users.size
+    assert_equal send(:User).first(:offset => 2, :limit => 1), users.next.first
+    assert_equal 1, users.next.size
+    assert_equal Pagify::NullPage.new(users.pager), users.next.next
+  end
+
+  def test_condition_chain
+    users_A = send(:User).all(:conditions => ['name = ?', 'A']).pagify :page => 1, :per_page => 1
+    assert_equal 1, users_A.size
+    assert_equal 2, users_A.pager.entries_count
+    assert_equal 2, users_A.pager.size # pages
+  end
+
+  def test_association_pagify
+    user = send(:User).first
+    user.pets.push(*send(:Pet).all)
+    assert user.save
+    assert_equal 3, user.pets.count
+
+    page = all_pets_with_name_godfat(user).pagify :page => 2, :per_page => 1
+    assert_equal 1, page.size
+    assert_equal 2, page.pager.size
+  end
+
+  def self.included test_case
+    test_case.module_eval do
+      # due to ruby const lookup is different from method lookup
+      def User; self.class.const_get(:User); end
+      def Pet;  self.class.const_get(:Pet); end
+    end
+
+    test_case.const_get(:User).module_eval do
+      create :name => 'A'
+      create :name => 'A'
+      create :name => 'B'
+    end
+
+    test_case.const_get(:Pet).module_eval do
+      create :name => 'Qoo'
+      create :name => 'godfat'
+      create :name => 'godfat'
+    end
+  end
+
+  # include Extlib::Hook
+  #
+  # private
+  # def i_give_up
+  #   if self.class == TestActiveRecord
+  #     skip "it's toooooo hard to implement this for active record!! patch wanted!"
+  #   end
+  # end
+  #
+  # [:test_same_pager_with_same_opts,
+  #  :test_page_correctness,
+  #  :test_condition_chain].each{ |test|
+  #   before test.to_sym, :i_give_up
+  # }
+
+end

data/test/helper_pagify.rb

@@ -0,0 +1,39 @@
+
+class TestPagify < TestCase
+  def self.data; @data ||= (0..100).to_a; end
+  def for_pager pager
+    # assume data.size is 101, data is [0,1,2,3...]
+    pager.per_page = 10
+    assert_equal 11, pager.size
+
+    null_page = Pagify::NullPage.new(pager)
+
+    assert_equal null_page, pager[0]
+    assert_equal((0..9).to_a, pager.page(1).to_a)
+    assert_equal((10..19).to_a, pager[2].to_a)
+    assert_equal(20, pager.page(3).first)
+    assert_equal((90..99).to_a, pager[10].to_a)
+    assert_equal([100], pager.page(11).to_a)
+    assert_equal null_page, pager.page(12)
+
+    assert_equal(pager[1], pager[2].prev)
+    assert_equal(pager.page(11), pager[10].next)
+    assert_equal null_page, pager[1].prev
+    assert_equal Pagify::NullPage.new(pager), pager[10].next.next
+
+    assert_equal pager[4].data, pager[4].fetch
+    assert_equal(pager[1], pager.pages.first)
+    assert_equal(pager[2], pager.to_a[1])
+    assert_equal(5050, pager.inject(0){|r, i| r += i.inject(&:+) })
+
+    assert_equal 4, pager[4].page
+
+    assert_equal 10, pager[2].begin
+    assert_equal 19, pager[2].end
+    assert_equal 100, pager[11].end
+
+    pager.null_page = false
+
+    assert_nil pager[12]
+  end
+end

data/test/test_active_record.rb

@@ -0,0 +1,66 @@
+
+require 'test/helper'
+require 'test/helper_pagify'
+require 'test/helper_model'
+
+require 'pagify/active_record'
+
+class TestActiveRecord < TestPagify
+  def test_for_active_record
+    for_pager Pagify::ActiveRecordPager.new(Topic)
+  end
+
+  class Topic
+    class << self
+      def count opts = {}
+        101
+      end
+      def find all, opts = {}
+        TestPagify.data[opts[:offset], opts[:limit]]
+      end
+    end
+  end
+
+  DataMapper.setup(:active_record, 'sqlite3:tmp/active_record.sqlite3')
+
+  class UserForActiveRecord
+    include DataMapper::Resource
+    def self.default_repository_name
+      :active_record
+    end
+    property :id, Serial
+    property :name, String
+    storage_names[default_repository_name] = 'users'
+    auto_migrate!
+  end
+
+  class PetForActiveRecord
+    include DataMapper::Resource
+    def self.default_repository_name
+      :active_record
+    end
+    property :id, Serial
+    property :name, String
+    property :user_id, Integer, :nullable => true
+    storage_names[default_repository_name] = 'pets'
+    auto_migrate!
+  end
+
+  ActiveRecord::Base.establish_connection(
+    :adapter => 'sqlite3', :database => 'tmp/active_record.sqlite3')
+
+  class User < ActiveRecord::Base
+    has_many :pets
+  end
+
+  class Pet < ActiveRecord::Base
+    belongs_to :user
+  end
+
+  include SuiteForModel
+
+  def all_pets_with_name_godfat user
+    user.pets.all(:conditions => ['name = ?', 'godfat'])
+  end
+
+end

data/test/test_array.rb

@@ -0,0 +1,19 @@
+
+require 'test/helper'
+require 'test/helper_pagify'
+
+class TestArray < TestPagify
+  def test_offset_bug
+    a = (0..9).to_a
+    pager = Pagify::ArrayPager.new a
+    pager.per_page = 5
+    assert_equal 5, pager[1].size
+    assert_equal 5, pager[2].size
+    assert_equal Pagify::NullPage.new(pager),  pager[3]
+  end
+
+  def test_for_array
+    for_pager Pagify::ArrayPager.new(TestPagify.data)
+  end
+
+end

data/test/test_basic.rb

@@ -0,0 +1,22 @@
+
+require 'test/helper'
+require 'test/helper_pagify'
+
+class TestBasic < TestPagify
+  def test_basic
+    pager = Pagify::BasicPager.new(
+      :fetcher => lambda{ |offset, per_page|
+        # if for rails,
+        # Data.find :all, :offset => offset, :limit => per_page
+        TestPagify.data[offset, per_page]
+      },
+      :counter => lambda{
+        # if for rails,
+        # Data.count
+        TestPagify.data.size
+      })
+
+    for_pager pager
+  end
+
+end

data/test/test_data_mapper.rb

@@ -0,0 +1,56 @@
+
+require 'test/helper'
+require 'test/helper_pagify'
+require 'test/helper_model'
+
+require 'pagify/data_mapper'
+
+class TestDataMapper < TestPagify
+  def test_for_data_mapper
+    for_pager Pagify::DataMapperPager.new(Topic)
+  end
+
+  class Topic
+    class << self
+      def count opts = {}
+        101
+      end
+      def all opts = {}
+        TestPagify.data[opts[:offset], opts[:limit]]
+      end
+      def query
+        nil
+      end
+      private
+      def with_scope query
+        yield
+      end
+    end
+  end
+
+  DataMapper.setup(:default, 'sqlite3::memory:')
+
+  class User
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+    has n, :pets
+  end
+
+  class Pet
+    include DataMapper::Resource
+    property :id, Serial
+    property :name, String
+    belongs_to :user, :nullable => true
+  end
+
+  User.auto_migrate!
+  Pet.auto_migrate!
+
+  include SuiteForModel
+
+  def all_pets_with_name_godfat user
+    user.pets.all(:name => 'godfat')
+  end
+
+end