paginater 0.0.5

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/paginater.rb

@@ -0,0 +1,31 @@
+
+begin
+  require 'grape'
+rescue LoadError
+  #do nothing
+end
+
+# load paginater components
+require 'paginater/constants'
+require 'paginater/core'
+require 'paginater/page/base_page'
+require 'paginater/page/page_links'
+require 'paginater/formatter'
+require "paginater/version"
+
+require 'active_record'
+
+require 'kaminari'
+require 'kaminari/grape'
+
+$stderr.puts <<-EOC if !defined?(Grape)
+  warning: no framework detected.
+EOC
+
+module Grape
+  module Formatter
+    module Paginater
+    end
+  end
+end
+

data/lib/paginater/constants.rb

@@ -0,0 +1,32 @@
+
+# lib/paginater/constants.rb
+
+module Grape
+  module Formatter
+    module Paginater
+      module Constants
+        class PaginaterError < RuntimeError
+        end
+        OneHour = Time.now + 3600
+        DefaultPageSize = 1
+        DefaultPage = 1
+        WrapperParam = :wrapper
+        SimpleParam = :simple
+        KaminariParam = :kaminari
+        SetCookie = "Set-Cookie"
+        # Link headers
+        HEADER_LINK = "Link".freeze
+        HEADER_NEXT = "X-Next".freeze
+        HEADER_LAST = "X-Last".freeze
+        META_REL = "rel".freeze
+        META_LAST = "last".freeze
+        META_NEXT = "next".freeze
+        META_FIRST = "first".freeze
+        META_PREV = "prev".freeze
+        PARAM_PAGE = "page".freeze
+        PARAM_PER_PAGE = "per_page".freeze
+        PARAM_START_PAGE = "start_page".freeze
+      end #Constants
+    end # Paginater
+  end # Formatter
+end # Grape

data/lib/paginater/core.rb

@@ -0,0 +1,54 @@
+# lib/paginater/core.rb
+
+module Grape
+  module Formatter
+    module Paginater
+      module Core
+      
+        def paginate(object, page, size)
+          if object.respond_to?(:to_a)
+            object = object.to_a
+            if page > object.count || page.zero?
+              raise Constants::PaginaterError, "invalid page #{page}"
+            end
+            if size.nil? || size <= 0
+              raise Constants::PaginaterError, "invalid size #{size}"
+            end
+            size = object.count if size > object.count
+            if page > page_count(object.count, size)
+              raise Constants::PaginaterError, "page #{page} out"
+            end
+            object = object[((page - 1) * size)...(page * size)]
+          else
+            puts "Can't paginate #{object.class}"
+            object
+          end
+        end
+      
+        def page_count(object_count, size)
+          page_count = if (object_count%size).zero?
+            object_count/size
+          else
+            object_count/size + 1
+          end
+        end
+       
+        def total_pages(object_count, size, max_pages = nil)
+          return 1 if size.nil?
+          total_pages_count = (object_count.to_f / size).ceil
+          if max_pages && max_pages < total_pages_count
+            max_pages
+          else
+            total_pages_count
+          end
+        end
+      
+        def simple(object, page = 1, size = 1)
+          object = object.to_a
+          object = object[((page.to_i - 1) * size.to_i)...(page.to_i * size.to_i)]
+        end
+      
+      end # Logic
+    end # Paginater
+  end # Formatter
+end # Grape

data/lib/paginater/formatter.rb

@@ -0,0 +1,131 @@
+
+# lib/paginater/formatter.rb
+
+module Grape
+  module Formatter
+    module Paginater
+      class << self
+      
+        include Core
+        include Constants
+
+        attr_reader :env, :endpoint, :original, :format
+        attr_reader :original_count, :page_requested, :total_pages
+      
+        def call(object, env)
+          
+          @env = env
+          @endpoint = env['api.endpoint']
+          @format = env['api.format']
+          @original = object
+          
+          check_params
+
+          case endpoint.options[:route_options][:paginater]
+
+          when KaminariParam
+            Kaminari.configure do |config|
+              config.default_per_page = 25 #=> 25?
+            end
+            if is_paginable? 
+              # TODO consider also options as :limit => x and :offset => y
+              @paginated = Kaminari.paginate_array(original.to_a).page(endpoint.params[:page]).per(endpoint.params[:size])
+            else
+              @paginated = original.page(endpoint.params[:page]).per(endpoint.params[:size])
+            end
+          
+          when SimpleParam
+            @paginated = paginate(original, endpoint.params[:page], endpoint.params[:size])
+          
+          when WrapperParam
+            # deprecating...
+            @paginated = wrap_content(paginate(original, endpoint.params[:page], endpoint.params[:size]))
+          
+          else
+            @paginated = original
+          end
+          
+          set_metadata
+
+          case format
+          when :txt
+            return @paginated.to_s if @paginated.respond_to?(:to_s)
+          when :json
+            Grape::Formatter::Json.call(@paginated, env)
+          else
+            raise PaginaterError, "format #{format} unknown"
+          end
+        
+        end
+      
+        private
+
+        def wrap_content(content)
+          object_paged = BasePage.new do |obj|
+            obj.content = content
+            obj.page = endpoint.params[:page]
+            obj.size = endpoint.params[:size]
+            obj.links = endpoint.header(HEADER_LINK)
+          end
+        end
+
+        def check_params
+          raise PaginaterError, "missing param" unless endpoint.params[:page]
+          raise PaginaterError, "first page must be 1" if endpoint.params[:page].to_i < 1
+          endpoint.params[:page] = endpoint.params[:page].to_i
+          endpoint.params[:size] = (!endpoint.params[:size] || endpoint.params[:size] == '0') ? DefaultPageSize : endpoint.params[:size].to_i
+          @page_requested = endpoint.params[:page] 
+        end
+
+        def set_metadata
+          @total_pages = if @paginated.respond_to?(:total_pages)
+              @paginated.total_pages
+            else
+              (@original.count/@paginated.count).ceil
+            end 
+          @original_count = if @original.respond_to?(:count)
+              @original.count
+            else
+              1
+            end
+          set_cookie
+          set_headers
+        end
+
+        def set_headers
+          size_param = endpoint.params[:size] == 1 ? "" : "&size=#{endpoint.params[:size]}"
+          first_link = { url: "#{env['PATH_INFO']}?page=#{1}#{size_param}", rel: META_FIRST}
+          next_link = { url: "#{env['PATH_INFO']}?page=#{@page_requested+1}#{size_param}", rel: META_NEXT} unless last_page?
+          prev_link = { url: "#{env['PATH_INFO']}?page=#{@page_requested-1}#{size_param}", rel: META_PREV} if @page_requested > 1
+          endpoint.header(HEADER_LINK, [first_link.to_s,next_link.to_s,prev_link.to_s].join(';'))
+        end
+
+        def set_cookie
+           endpoint.cookies[:paginater] = {
+             :content => "#{@page_requested}/#{@total_pages}/#{@original_count}",
+             :domain => env['HTTP_HOST'],
+             :path => endpoint.options[:path],
+             :expires => OneHour
+           }
+           endpoint.header(SetCookie, endpoint.cookies[:paginater][:content])
+       end
+
+        def is_paginable?
+          original.is_a?(Enumerable)
+          # original.is_a?(Array) || original.is_a?(Hash)
+          # original.respond_to?(:to_a)
+        end
+
+        def last_page?
+          @page_requested == page_count(@original_count, endpoint.params[:size])
+        end
+      
+        def log_me text
+          Grape::API.logger.info "#{Time.now} >> #{text}"
+        end
+      
+      end # class
+    end # Paginater
+  end # Formatter
+end # Grape
+

data/lib/paginater/page/base_page.rb

@@ -0,0 +1,31 @@
+
+# lib/paginater/page/base_page.rb
+
+module Grape
+  module Formatter
+    module Paginater
+      class BasePage
+        attr_accessor :content, :page, :next_page, :prev_page, :size
+        attr_accessor :code
+        attr_accessor :links
+        def initialize
+          yield self if block_given?
+        end
+        def code(&block)
+          if block_given?
+            @code = block
+          else
+            @code = proc {}
+          end 
+        end
+        def count
+          @content.count ||= 1
+        end
+        # TODO: implement me...
+        def render
+          @code.call self
+        end
+      end # BasePage
+    end # Paginater
+  end # Formatter
+end  # Grape

data/lib/paginater/page/page_links.rb

@@ -0,0 +1,50 @@
+# lib/paginater/page/page_links.rb
+
+module Grape
+  module Formatter
+    module Paginater
+      class PageLinks
+        include Constants
+
+        DELIM_LINKS = ",".freeze
+
+        attr_accessor :first, :last, :next, :prev
+
+# let(:header) { {"Link" =>
+# "<https://api.com/users?page=4&size=20>;
+# rel=\"next\", <...>;
+# rel=\"last\", <...>;
+# rel=\"first\", <...>;
+# rel=\"prev\""}
+
+        def initialize(response_headers)
+          link_header = response_headers[HEADER_LINK]
+          if link_header
+            return unless link_header =~ /(next|first|last|prev)/
+
+            link_header.split(DELIM_LINKS).each do |link|
+              if link.strip =~ /<([^>]+)>; rel=\"([^\"]+)\"/
+                url_part, meta_part = $1, $2
+                next if !url_part || !meta_part
+                case meta_part
+                when META_FIRST
+                  self.first = url_part
+                when META_LAST
+                  self.last = url_part
+                when META_NEXT
+                  self.next = url_part
+                when META_PREV
+                  self.prev = url_part
+                end
+              end
+            end
+          else
+            # When on the first page
+            self.next = response_headers[HEADER_NEXT]
+            self.last = response_headers[HEADER_LAST]
+          end
+        end
+      end # PageLinks
+    end # Paginater
+  end # Formatter
+end # Grape

data/lib/paginater/version.rb

@@ -0,0 +1,3 @@
+module Paginater
+  VERSION = '0.0.5'
+end

data/paginater.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'paginater/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "paginater"
+  gem.version       = Paginater::VERSION
+  gem.platform      = Gem::Platform::RUBY
+  gem.authors       = ["zeroed"]
+  gem.description   = "gem for foo pagination features in Grape"
+  gem.summary       = %q{YAPG: yet another pagination gem}
+  gem.homepage      = "https://github.com/zeroed/paginater"
+  gem.license       = "MIT"
+  gem.rubyforge_project = "paginater"
+
+  gem.add_dependency 'bundler'
+  gem.add_dependency 'rake'
+  gem.add_dependency 'rspec'
+  gem.add_dependency 'rack-test'
+  gem.add_dependency 'rspec-rails'
+  gem.add_dependency 'cookiejar'
+  gem.add_dependency 'activerecord'
+  gem.add_dependency 'sqlite3'
+
+  gem.add_dependency 'grape'
+
+  gem.add_dependency 'kaminari' # , :require => 'kaminari/grape'
+
+  gem.add_development_dependency 'thin'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/spec/paginater/paginatable_array_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Kaminari::PaginatableArray do
+  it { should have(0).items }
+
+  context 'specifying limit and offset when initializing' do
+    subject { Kaminari::PaginatableArray.new((1..100).to_a, :limit => 10, :offset => 20) }
+    its(:current_page) { should == 3 }
+  end
+
+  let(:array) { Kaminari::PaginatableArray.new((1..100).to_a) }
+  describe '#page' do
+    shared_examples_for 'the first page of array' do
+      it { should have(25).users }
+      its(:current_page) { should == 1 }
+      its(:first) { should == 1 }
+    end
+
+    shared_examples_for 'blank array page' do
+      it { should have(0).items }
+    end
+
+    context 'page 1' do
+      subject { array.page 1 }
+      it_should_behave_like 'the first page of array'
+    end
+
+    context 'page 2' do
+      subject { array.page 2 }
+      it { should have(25).users }
+      its(:current_page) { should == 2 }
+      its(:first) { should == 26 }
+    end
+
+    context 'page without an argument' do
+      subject { array.page }
+      it_should_behave_like 'the first page of array'
+    end
+
+    context 'page < 1' do
+      subject { array.page 0 }
+      it_should_behave_like 'the first page of array'
+    end
+
+    context 'page > max page' do
+      subject { array.page 5 }
+      it_should_behave_like 'blank array page'
+    end
+  end
+
+  describe '#per' do
+    context 'page 1 per 5' do
+      subject { array.page(1).per(5) }
+      it { should have(5).users }
+      its(:first) { should == 1 }
+    end
+  end
+
+  describe '#total_pages' do
+    context 'per 25 (default)' do
+      subject { array.page }
+      its(:total_pages) { should == 4 }
+    end
+
+    context 'per 7' do
+      subject { array.page(2).per(7) }
+      its(:total_pages) { should == 15 }
+    end
+
+    context 'per 65536' do
+      subject { array.page(50).per(65536) }
+      its(:total_pages) { should == 1 }
+    end
+
+    context 'per 0 (using default)' do
+      subject { array.page(50).per(0) }
+      its(:total_pages) { should == 4 }
+    end
+
+    context 'per -1 (using default)' do
+      subject { array.page(5).per(-1) }
+      its(:total_pages) { should == 4 }
+    end
+
+    context 'per "String value that can not be converted into Number" (using default)' do
+      subject { array.page(5).per('aho') }
+      its(:total_pages) { should == 4 }
+    end
+  end
+
+  describe '#current_page' do
+    context 'page 1' do
+      subject { array.page }
+      its(:current_page) { should == 1 }
+    end
+
+    context 'page 2' do
+      subject { array.page(2).per 3 }
+      its(:current_page) { should == 2 }
+    end
+  end
+
+  describe '#count' do
+    context 'page 1' do
+      subject { array.page }
+      its(:count) { should == 25 }
+    end
+
+    context 'page 2' do
+      subject { array.page 2 }
+      its(:count) { should == 25 }
+    end
+  end
+
+  context 'when setting total count explicitly' do
+    subject { Kaminari::PaginatableArray.new((1..10).to_a, :total_count => 9999).page(5).per(10) }
+    it { should have(10).items }
+    its(:first) { should == 1 }
+    its(:total_count) { should == 9999 }
+  end
+end
+