lhs 3.4.2 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3487e37bda58a0a1b774e11778cb239f16489c95
-  data.tar.gz: 702c8edef48c3971724878e0eff8416b36dac3db
+  metadata.gz: a00b04e289a4748446105fc8701ddabc87f58d77
+  data.tar.gz: 44f10bf8b376e4d849506074f39fd4373e7dc13b
 SHA512:
-  metadata.gz: 035800d35582128787be14d1dcc58cd43e1fe7fece5165f3ec84c63dc41bc0f295ac5423f282f3f747e98479ef88e7c7e3bf59e09a9e9408f1090078a688e953
-  data.tar.gz: 815442c0a04adff1b361a9f5015cb02f8d7e749ef879cf4e4245bfd1d4fe479bf6048b59a83122fd93d4faf87799a093d9d18310353a2de5eda161aeedb90ce9
+  metadata.gz: 15b4da5598314dc9ad1029e1c2b9562ef0610bb4f2f240e6c1be7d813a49e2e94dbebed77fd4f0a8c699998970069274a4b4a0939bc49d52769b416315259873
+  data.tar.gz: 83a9e1c944011beaea79e4a0b3c6cebaef12305234a91ebc0ed94741567a5dd919f9953af7d7d8e485bc944326d914f462ff91fa75507c4873ee42a2b752fa00

data/README.md

@@ -111,9 +111,11 @@ If no record is found, `nil` is returned.
 ```ruby
 data = Feedback.all
 data.count # 998
-data.total # 998
+data.length # 998
 ```
 
+[Count vs. Length](#count-vs-length)
+
 `find_each` is a more fine grained way to process single records that are fetched in batches.
 
 ```ruby
@@ -355,46 +357,90 @@ unless user.valid?
 end
 ```
 
-## Collections: Offset / Limit / Pagination
+## How to work with paginated APIs
+
+LHS supports paginated APIs and it also supports various pagination strategies and by providing configuration possibilities.
 
-You can paginate by passing offset, and limit params. They will be forwarded to the service.
+LHS diffentiates between the *pagination strategy* (how items/pages are navigated) itself and *pagination keys* (how stuff is named).
 
+*Example 1 "offset"-strategy (default configuration)*
 ```ruby
-data = Feedback.where(limit: 50)
-data.count // 50
-Feedback.where(limit: 50, offset: 51)
+# API response
+{
+  items: [{...}, ...]
+  total: 300,
+  limit: 100,
+  offset: 0
+}
+# Next 'pages' are navigated with offset: 100, offset: 200, ...
+
+# Nothing has to be configured in LHS because this is default pagination naming and strategy
+class Results < LHS::Record
+  endpoint 'results'
+end
 ```
 
-`total` provides total amount of items (even if paginated).
-`limit` provides amount of items per page.
-`offset` provides how many items where skipped to start the current page.
-
-### Configure the name of the keys for offset, limit, total and name of items
-
-Endpoints provide different interfaces to deal with paginated resources.
-They differ for example for the key that is used for providing the current page items, the total amount of items, the current page size etc.
-In order to have `LHS::Record` deal with those different interfaces you can configure it:
+*Example 2 "page"-strategy and some naming configuration*
+```ruby
+# API response
+{
+  docs: [{...}, ...]
+  totalPages: 3,
+  limit: 100,
+  page: 1
+}
+# Next 'pages' are navigated with page: 1, offset: 2, ...
+
+# How LHS has to be configured
+class Results < LHS::Record
+  configuration items_key: 'docs', total_key: 'totalPages', pagination_key: 'page', pagination_strategy: 'page'
+  endpoint 'results'
+end
+```
 
+*Example 3 "start"-strategy and naming configuration*
 ```ruby
-class Search < LHS::Record
-  configuration items: :docs, limit: :size, offset: :start, total: :totalResults
-  endpoint ':search/:type'
+# API response
+{
+  results: [{...}, ...]
+  total: 300,
+  badgeSize: 100,
+  startAt: 1
+}
+# Next 'pages' are navigated with startWith: 101, startWith: 201, ...
+
+# How LHS has to be configured
+class Results < LHS::Record
+  configuration items_key: 'results', limit_key: 'badgeSize', pagination_key: 'startAt', pagination_strategy: 'start'
+  endpoint 'results'
 end
 ```
-`items` key used to determine items of the current page.
-`limit` key used to work with page limits.
-`offset` key used to paginate multiple pages.
-`total` key used to determine the total amount of items.
+
+`items_key` key used to determine items of the current page (e.g. `docs`, `items`, etc.).
+
+`limit_key` key used to work with page limits (e.g. `size`, `limit`, etc.)
+
+`pagination_key` key used to paginate multiple pages (e.g. `offset`, `page`, `startAt` etc.).
+
+`pagination_strategy` used to configure the strategy used for navigating (e.g. `offset`, `page`, `start`, etc.).
+
+`total_key` key used to determine the total amount of items (e.g. `total`, `totalResults`, etc.).
+
+In case of paginated resources it's important to know the difference between [count vs. length](#count-vs-length)
 
 ### Partial Kaminari support
 
 LHS implements an interface that makes it partially working with Kaminari.
 
-For example, you can use kaminari to render paginations based on LHS Records:
+The kaminari’s page parameter is in params[:page]. For example, you can use kaminari to render paginations based on LHS Records. Typically, your code will look like this:
 
 ```ruby
 # controller
-@items = Record.where(offset: offset, limit: limit)
+params[:page] = 0 if params[:page].nil?
+page = params[:page].to_i
+limit = 100
+offset = (page - 1) * limit
+@items = Record.where({ limit: limit, offset: offset }))
 ```
 
 ```ruby
@@ -402,7 +448,7 @@ For example, you can use kaminari to render paginations based on LHS Records:
 = paginate @items
 ```
 
-### form_for Helper
+## form_for Helper
 Rails `form_for` view-helper can be used in combination with instances of LHS::Record to autogenerate forms:
 ```
 <%= form_for(@instance, url: '/create') do |f| %>
@@ -411,3 +457,11 @@ Rails `form_for` view-helper can be used in combination with instances of LHS::R
   <%= f.submit "Create" %>
 <% end %>
 ```
+
+## Count vs. Length
+
+The behaviour of `count` and `length` is based on ActiveRecord's behaviour.
+
+`count` Determine the number of elements by taking the number of total elements that is provided by the endpoint/api.
+
+`length` This returns the number of elements loaded from an endpoint/api. In case of paginated resources this can be different to count, as it depends on how many pages have been loaded.

data/lib/lhs/collection.rb

@@ -6,19 +6,12 @@ Dir[File.dirname(__FILE__) + '/concerns/collection/*.rb'].each { |file| require
 class LHS::Collection < LHS::Proxy
   include InternalCollection
 
-  delegate :select, to: :_collection
-  delegate :_record, to: :_data
+  delegate :select, :length, :size, to: :_collection
+  delegate :_record, :_raw, to: :_data
+  delegate :limit, :count, :total, :limit, :offset, :current_page, :start, to: :_pagination
 
-  def total
-    _data._raw[_record.total_key]
-  end
-
-  def limit
-    _data._raw[_record.limit_key]
-  end
-
-  def offset
-    _data._raw[_record.offset_key]
+  def _pagination
+    _record.pagination(_data)
   end
 
   def href
@@ -31,8 +24,6 @@ class LHS::Collection < LHS::Proxy
     Collection.new(raw, _data, _record)
   end
 
-  delegate :_raw, to: :_data
-
   protected
 
   def method_missing(name, *args, &block)

data/lib/lhs/concerns/collection/internal_collection.rb

@@ -12,7 +12,7 @@ class LHS::Collection < LHS::Proxy
       include Enumerable
 
       attr_accessor :raw
-      delegate :last, :sample, :[], :present?, :blank?, :empty?, to: :raw
+      delegate :length, :size, :last, :sample, :[], :present?, :blank?, :empty?, to: :raw
 
       def initialize(raw, parent, record)
         self.raw = raw

data/lib/lhs/concerns/record/all.rb

@@ -31,18 +31,23 @@ class LHS::Record
       end
 
       def request_all_the_rest(data, params)
-        total_left = data._raw[total_key] - data.count
-        limit = data._raw[limit_key] || data.count
-        if limit > 0
-          requests = total_left / limit
-          requests.times do |i|
-            offset = limit * (i + 1) + 1
-            data._raw[items_key].concat all_items_from request(
+        pagination = data._record.pagination(data)
+        if pagination.pages_left
+          last_data = data
+          pagination.pages_left.times do |_index|
+            return data if last_data.length.zero?
+            pagination = data._record.pagination(last_data)
+            response_data = request(
               params: params.merge(
-                data._record.limit_key => limit,
-                data._record.offset_key => offset
+                data._record.limit_key => pagination.limit,
+                data._record.pagination_key => pagination.next_offset
               )
             )
+            data._raw[items_key].concat all_items_from response_data
+            data._raw[limit_key] = response_data._raw[limit_key]
+            data._raw[total_key] = response_data._raw[total_key]
+            data._raw[pagination_key] = response_data._raw[pagination_key]
+            last_data = response_data
           end
         end
       end

data/lib/lhs/concerns/record/configuration.rb

@@ -11,23 +11,29 @@ class LHS::Record
 
     module ClassMethods
       def configuration(args)
-        @configuration ||= args.freeze || {}
+        @configuration = args.freeze || {}
       end
 
       def items_key
-        @configuration.try(:[], :items) || :items
+        @configuration.try(:[], :items_key) || :items
       end
 
       def limit_key
-        @configuration.try(:[], :limit) || :limit
+        @configuration.try(:[], :limit_key) || :limit
       end
 
       def total_key
-        @configuration.try(:[], :total) || :total
+        @configuration.try(:[], :total_key) || :total
       end
 
-      def offset_key
-        @configuration.try(:[], :offset) || :offset
+      # Key used for determine current page
+      def pagination_key
+        @configuration.try(:[], :pagination_key) || :offset
+      end
+
+      # Strategy used for calculationg next pages and navigate pages
+      def pagination_strategy
+        @configuration.try(:[], :pagination_strategy) || :offset
       end
     end
   end

data/lib/lhs/concerns/record/find.rb

@@ -23,7 +23,7 @@ class LHS::Record
       def find_with_parameters(params)
         data = request(params: params)
         if data._proxy.is_a?(LHS::Collection)
-          fail LHC::NotFound.new('Requested unique item. Multiple were found.', data._request.response) if data.count > 1
+          fail LHC::NotFound.new('Requested unique item. Multiple were found.', data._request.response) if data.length > 1
           data.first || fail(LHC::NotFound.new('No item was found.', data._request.response))
         else
           data

data/lib/lhs/concerns/record/pagination.rb

@@ -4,33 +4,24 @@ class LHS::Record
 
   module Pagination
     extend ActiveSupport::Concern
+    # Kaminari-Interface
+    delegate :current_page, :first_page, :last_page, :prev_page, :next_page, :limit_value, :total_pages, to: :_pagination
 
-    def current_page
-      offset + 1
+    def _pagination
+      self.class.pagination(_data)
     end
 
-    def first_page
-      1
-    end
-
-    def last_page
-      total_pages
-    end
-
-    def prev_page
-      current_page - 1
-    end
-
-    def next_page
-      current_page + 1
-    end
-
-    def limit_value
-      limit
-    end
-
-    def total_pages
-      total / limit
+    module ClassMethods
+      def pagination(data)
+        case data._record.pagination_strategy.to_sym
+        when :page
+          PagePagination.new(data)
+        when :start
+          StartPagination.new(data)
+        else
+          OffsetPagination.new(data)
+        end
+      end
     end
   end
 end

data/lib/lhs/concerns/record/request.rb

@@ -92,7 +92,7 @@ class LHS::Record
       end
 
       def multiple_requests(options)
-        options = options.map { |option| process_options(option) }
+        options = options.map { |option| process_options(option, find_endpoint(option[:params])) }
         responses = LHC.request(options)
         data = responses.map { |response| LHS::Data.new(response.body, nil, self, response.request) }
         data = LHS::Data.new(data, nil, self)
@@ -107,11 +107,8 @@ class LHS::Record
       end
 
       # Merge explicit params and take configured endpoints options as base
-      def process_options(options)
-        options ||= {}
-        options = options.dup
+      def process_options(options, endpoint)
         options[:params].deep_symbolize_keys! if options[:params]
-        endpoint = find_endpoint(options[:params])
         options = (endpoint.options || {}).merge(options)
         options[:url] = compute_url!(options[:params]) unless options.key?(:url)
         merge_explicit_params!(options[:params])
@@ -135,8 +132,11 @@ class LHS::Record
       end
 
       def single_request(options)
-        response = LHC.request(process_options(options))
-        data = LHS::Data.new(response.body, nil, self, response.request)
+        options ||= {}
+        options = options.dup
+        endpoint = find_endpoint(options[:params])
+        response = LHC.request(process_options(options, endpoint))
+        data = LHS::Data.new(response.body, nil, self, response.request, endpoint)
         handle_includes(including, data) if including
         data
       end

data/lib/lhs/data.rb

@@ -5,17 +5,18 @@ Dir[File.dirname(__FILE__) + '/concerns/data/*.rb'].each { |file| require file }
 class LHS::Data
   include Json
 
-  delegate :instance_methods, :items_key, :limit_key, :total_key, :offset_key, to: :class
+  delegate :instance_methods, :items_key, :limit_key, :total_key, :pagination_key, to: :class
 
   # prevent clashing with attributes of underlying data
-  attr_accessor :_proxy, :_raw, :_parent, :_record, :_request
+  attr_accessor :_proxy, :_raw, :_parent, :_record, :_request, :_endpoint
 
-  def initialize(input, parent = nil, record = nil, request = nil)
+  def initialize(input, parent = nil, record = nil, request = nil, endpoint = nil)
     self._raw = raw_from_input(input)
     self._parent = parent
     self._record = record
     self._proxy = proxy_from_input(input)
     self._request = request
+    self._endpoint = endpoint
   end
 
   # merging data

data/lib/lhs/pagination.rb

@@ -0,0 +1,101 @@
+# Pagination is used to navigate paginateable collections
+class Pagination
+
+  delegate :_record, to: :data
+  attr_accessor :data
+
+  def initialize(data)
+    self.data = data
+  end
+
+  # as standard in Rails' ActiveRecord count is not summing up, but using the number provided from data source
+  def count
+    total
+  end
+
+  def total
+    data._raw[_record.total_key.to_sym]
+  end
+
+  def limit
+    data._raw[_record.limit_key.to_sym] || LHS::Record::DEFAULT_LIMIT
+  end
+
+  def offset
+    data._raw[_record.pagination_key.to_sym]
+  end
+  alias current_page offset
+  alias start offset
+
+  def pages_left
+    total_pages - current_page
+  end
+
+  def next_offset
+    fail 'to be implemented in subclass'
+  end
+
+  def current_page
+    fail 'to be implemented in subclass'
+  end
+
+  def first_page
+    1
+  end
+
+  def last_page
+    total_pages
+  end
+
+  def prev_page
+    current_page - 1
+  end
+
+  def next_page
+    current_page + 1
+  end
+
+  def limit_value
+    limit
+  end
+
+  def total_pages
+    (total.to_f / limit).ceil
+  end
+end
+
+class PagePagination < Pagination
+
+  def current_page
+    offset
+  end
+
+  def next_offset
+    current_page + 1
+  end
+
+end
+
+class StartPagination < Pagination
+
+  def current_page
+    (offset + limit - 1) / limit
+  end
+
+  def next_offset
+    offset + limit
+  end
+
+end
+
+class OffsetPagination < Pagination
+
+  def current_page
+    (offset + limit) / limit
+  end
+
+  def next_offset
+    offset + limit
+  end
+
+end

data/lib/lhs/record.rb

@@ -17,6 +17,7 @@ class LHS::Record
   include Pagination
 
   delegate :_proxy, to: :_data
+  delegate :_endpoint, to: :_data
 
   def initialize(data = nil)
     data = LHS::Data.new({}, nil, self.class) unless data

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = "3.4.2"
+  VERSION = "4.0.0"
 end

data/spec/collection/configurable_spec.rb

@@ -4,32 +4,29 @@ describe LHS::Collection do
   let(:search) { 'http://local.ch/search' }
   let(:limit) { 10 }
   let(:total) { 20 }
-  let(:offset) { 0 }
-  let(:first_response_data) do
-    {
-      docs: (1..10).to_a,
-      start: offset,
-      size: limit,
-      totalResults: total
-    }
-  end
-  let(:second_response_data) do
-    {
-      docs: (11..20).to_a,
-      start: offset,
-      size: limit,
-      totalResults: total
-    }
-  end
 
   before(:each) do
     LHC.config.placeholder('search', search)
     class Search < LHS::Record
-      configuration items: :docs, limit: :size, offset: :start, total: :totalResults
+      configuration items_key: :docs, limit_key: :size, pagination_key: :start, pagination_strategy: :start, total_key: :totalResults
       endpoint ':search/:type'
     end
-    stub_request(:get, "http://local.ch/search/phonebook?size=10").to_return(body: first_response_data.to_json)
-    stub_request(:get, "http://local.ch/search/phonebook?size=10&start=11").to_return(body: second_response_data.to_json)
+    stub_request(:get, "http://local.ch/search/phonebook?size=10").to_return(
+      body: {
+        docs: (1..10).to_a,
+        start: 1,
+        size: limit,
+        totalResults: total
+      }.to_json
+    )
+    stub_request(:get, "http://local.ch/search/phonebook?size=10&start=11").to_return(
+      body: {
+        docs: (11..20).to_a,
+        start: 11,
+        size: limit,
+        totalResults: total
+      }.to_json
+    )
   end
 
   context 'lets you configure how to deal with collections' do
@@ -38,7 +35,7 @@ describe LHS::Collection do
       expect(results.count).to eq total
       expect(results.total).to eq total
       expect(results.limit).to eq limit
-      expect(results.offset).to eq offset
+      expect(results.offset).to eq 11
     end
   end
 end

data/spec/record/find_in_batches_spec.rb

@@ -32,13 +32,13 @@ describe LHS::Collection do
       stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=201").to_return(status: 200, body: api_response((201..300).to_a, 201))
       stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=301").to_return(status: 200, body: api_response((301..400).to_a, 301))
       stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=401").to_return(status: 200, body: api_response((401..total).to_a, 401))
-      count = 0
+      length = 0
       Record.find_in_batches do |records|
-        count += records.count
+        length += records.length
         expect(records).to be_kind_of Record
         expect(records._proxy).to be_kind_of LHS::Collection
       end
-      expect(count).to eq total
+      expect(length).to eq total
     end
 
     it 'adapts to backend max limit' do
@@ -47,19 +47,19 @@ describe LHS::Collection do
       stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=201").to_return(status: 200, body: api_response((201..300).to_a, 201))
       stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=301").to_return(status: 200, body: api_response((301..400).to_a, 301))
       stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=401").to_return(status: 200, body: api_response((401..total).to_a, 401))
-      count = 0
+      length = 0
       Record.find_in_batches(batch_size: 230) do |records|
-        count += records.count
+        length += records.length
         expect(records).to be_kind_of Record
         expect(records._proxy).to be_kind_of LHS::Collection
       end
-      expect(count).to eq total
+      expect(length).to eq total
     end
 
     it 'forwards offset' do
       stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=401").to_return(status: 200, body: api_response((401..total).to_a, 401))
       Record.find_in_batches(start: 401) do |records|
-        expect(records.count).to eq(total - 400)
+        expect(records.length).to eq(total - 400)
       end
     end
   end

data/spec/record/paginatable_collection_spec.rb

@@ -0,0 +1,278 @@
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before(:each) { LHC.config.placeholder('datastore', datastore) }
+  let(:datastore) { 'http://local.ch/v2' }
+
+  context 'default pagination behaviour' do
+    before(:each) do
+      class Record < LHS::Record
+        endpoint ':datastore/feedbacks'
+      end
+    end
+
+    it 'also works when there is no item in the first response' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: [], total: 300, offset: 0 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of LHS::Collection
+      expect(all.length).to eq 0
+    end
+
+    it 'also works when there is no total in the stubbing' do
+      stub_request(:get, %r{/feedbacks}).to_return(body: { items: (1..100).to_a }.to_json)
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of LHS::Collection
+      expect(all.length).to eq 100
+    end
+
+    it 'also works when there is no key "items" in the stubbing' do
+      stub_request(:get, %r{/feedbacks}).to_return(body: (1..100).to_a.to_json)
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of LHS::Collection
+      expect(all.length).to eq 100
+    end
+  end
+
+  context 'pagination using offset(0,100,200,...)' do
+    before(:each) do
+      class Record < LHS::Record
+        configuration pagination_strategy: 'offset', pagination_key: 'offset'
+        endpoint ':datastore/feedbacks'
+      end
+    end
+
+    it 'fetches all records from the backend' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 300, offset: 0 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=100")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 300, offset: 100 }.to_json
+        )
+      last_request = stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=200")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, limit: 100, total: 300, offset: 200 }.to_json
+        )
+      all = Record.all
+      assert_requested last_request
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of LHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'fetches all, also if there is a rest and the total is not divideable trough the limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 223, offset: 0 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=100")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 223, offset: 100 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=200")
+        .to_return(
+          status: 200,
+          body: { items: (201..223).to_a, limit: 100, total: 223, offset: 200 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of LHS::Collection
+      expect(all.count).to eq 223
+      expect(all.last).to eq 223
+    end
+
+    it 'also fetches all when there is not meta information for limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, total: 300, offset: 0 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=100")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, total: 300, offset: 100 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=200")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, total: 300, offset: 200 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of LHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+  end
+
+  context 'pagination using page(1,2,3,...)' do
+    before(:each) do
+      class Record < LHS::Record
+        configuration pagination_strategy: 'page', pagination_key: 'page'
+        endpoint ':datastore/feedbacks'
+      end
+    end
+
+    it 'fetches all records from the backend' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 300, page: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=2")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 300, page: 2 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=3")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, limit: 100, total: 300, page: 3 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of LHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'also fetches all when there is not meta information for limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, total: 300, page: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=2")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, total: 300, page: 2 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=3")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, total: 300, page: 3 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of LHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'fetches all, also if there is a rest and the total is not divideable trough the limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 223, page: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=2")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 223, page: 2 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=3")
+        .to_return(
+          status: 200,
+          body: { items: (201..223).to_a, limit: 100, total: 223, page: 3 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of LHS::Collection
+      expect(all.count).to eq 223
+      expect(all.last).to eq 223
+    end
+  end
+
+  context 'pagination using start(1,101,201,...)' do
+    before(:each) do
+      class Record < LHS::Record
+        configuration pagination_strategy: 'start', pagination_key: 'start'
+        endpoint ':datastore/feedbacks'
+      end
+    end
+
+    it 'fetches all records from the backend' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 300, start: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=101")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 300, start: 101 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=201")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, limit: 100, total: 300, start: 201 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of LHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'also fetches all when there is not meta information for limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, total: 300, start: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=101")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, total: 300, start: 101 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=201")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, total: 300, start: 201 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of LHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'fetches all, also if there is a rest and the total is not divideable trough the limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 223, start: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=101")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 223, start: 101 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=201")
+        .to_return(
+          status: 200,
+          body: { items: (201..223).to_a, limit: 100, total: 223, start: 201 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of LHS::Collection
+      expect(all.count).to eq 223
+      expect(all.last).to eq 223
+    end
+  end
+end

data/spec/record/pagination_spec.rb

@@ -56,5 +56,14 @@ describe LHS::Record do
     it 'responds to next_page' do
       expect(record.next_page).to eq(next_page)
     end
+
+    context 'when amount of total pages is not diviable by the limit' do
+      let(:total) { 2738 }
+      let(:limit) { 100 }
+
+      it 'rounds up' do
+        expect(record.total_pages).to eq(28)
+      end
+    end
   end
 end

data/spec/support/cleanup_records.rb

@@ -13,6 +13,7 @@ RSpec.configure do |config|
   config.before(:each) do
     LHS::Record::CHILDREN.each do |child|
       child.endpoints = [] if !child.name['LHS']
+      child.configuration({}) if !child.name['LHS']
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 3.4.2
+  version: 4.0.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-06 00:00:00.000000000 Z
+date: 2016-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc
@@ -202,6 +202,7 @@ files:
 - lib/lhs/endpoint.rb
 - lib/lhs/errors.rb
 - lib/lhs/item.rb
+- lib/lhs/pagination.rb
 - lib/lhs/proxy.rb
 - lib/lhs/record.rb
 - lib/lhs/version.rb
@@ -274,7 +275,6 @@ files:
 - spec/item/validation_spec.rb
 - spec/proxy/load_spec.rb
 - spec/rails_helper.rb
-- spec/record/all_spec.rb
 - spec/record/build_spec.rb
 - spec/record/create_spec.rb
 - spec/record/creation_failed_spec.rb
@@ -291,6 +291,7 @@ files:
 - spec/record/mapping_spec.rb
 - spec/record/model_name_spec.rb
 - spec/record/new_spec.rb
+- spec/record/paginatable_collection_spec.rb
 - spec/record/pagination_spec.rb
 - spec/record/persisted_spec.rb
 - spec/record/request_spec.rb
@@ -398,7 +399,6 @@ test_files:
 - spec/item/validation_spec.rb
 - spec/proxy/load_spec.rb
 - spec/rails_helper.rb
-- spec/record/all_spec.rb
 - spec/record/build_spec.rb
 - spec/record/create_spec.rb
 - spec/record/creation_failed_spec.rb
@@ -415,6 +415,7 @@ test_files:
 - spec/record/mapping_spec.rb
 - spec/record/model_name_spec.rb
 - spec/record/new_spec.rb
+- spec/record/paginatable_collection_spec.rb
 - spec/record/pagination_spec.rb
 - spec/record/persisted_spec.rb
 - spec/record/request_spec.rb

data/spec/record/all_spec.rb

@@ -1,68 +0,0 @@
-require 'rails_helper'
-
-describe LHS::Collection do
-  let(:datastore) { 'http://local.ch/v2' }
-
-  before(:each) do
-    LHC.config.placeholder('datastore', datastore)
-    class Record < LHS::Record
-      endpoint ':datastore/:campaign_id/feedbacks'
-      endpoint ':datastore/feedbacks'
-    end
-  end
-
-  context 'all' do
-    it 'fetches all records from the backend' do
-      stub_request(:get, "#{datastore}/feedbacks?limit=100")
-        .to_return(status: 200, body: { items: (1..100).to_a, total: 300, limit: 100, offset: 0 }.to_json)
-      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=101")
-        .to_return(status: 200, body: { items: (101..200).to_a, total: 300, limit: 100, offset: 101 }.to_json)
-      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=201")
-        .to_return(status: 200, body: { items: (201..300).to_a, total: 300, limit: 100, offset: 201 }.to_json)
-      all = Record.all
-      expect(all).to be_kind_of Record
-      expect(all._data._proxy).to be_kind_of LHS::Collection
-      expect(all.count).to eq 300
-      expect(all.last).to eq 300
-    end
-
-    it 'also fetches all when there is not meta information for limit' do
-      stub_request(:get, "#{datastore}/feedbacks?limit=100")
-        .to_return(status: 200, body: { items: (1..100).to_a, total: 300, offset: 0 }.to_json)
-      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=101")
-        .to_return(status: 200, body: { items: (101..200).to_a, total: 300, offset: 101 }.to_json)
-      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=201")
-        .to_return(status: 200, body: { items: (201..300).to_a, total: 300, offset: 201 }.to_json)
-      all = Record.all
-      expect(all).to be_kind_of Record
-      expect(all._proxy).to be_kind_of LHS::Collection
-      expect(all.count).to eq 300
-      expect(all.last).to eq 300
-    end
-
-    it 'also works when there is no item in the first response' do
-      stub_request(:get, "#{datastore}/feedbacks?limit=100")
-        .to_return(status: 200, body: { items: [], total: 300, offset: 0 }.to_json)
-      all = Record.all
-      expect(all).to be_kind_of Record
-      expect(all._proxy).to be_kind_of LHS::Collection
-      expect(all.count).to eq 0
-    end
-
-    it 'alsow works when there is no total in the stubbing' do
-      stub_request(:get, %r{/feedbacks}).to_return(body: { items: (1..100).to_a }.to_json)
-      all = Record.all
-      expect(all).to be_kind_of Record
-      expect(all._proxy).to be_kind_of LHS::Collection
-      expect(all.count).to eq 100
-    end
-
-    it 'alsow works when there is no key "items" in the stubbing' do
-      stub_request(:get, %r{/feedbacks}).to_return(body: (1..100).to_a.to_json)
-      all = Record.all
-      expect(all).to be_kind_of Record
-      expect(all._proxy).to be_kind_of LHS::Collection
-      expect(all.count).to eq 100
-    end
-  end
-end