lhs 7.4.1 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6716a12c5196762c84c68b946df362158e9c62f0
-  data.tar.gz: 594c16d1e84a6873c77560ae6ae229149c7e4813
+  metadata.gz: 0e172deae82bb63cb78f7a2d96a261620ecf09af
+  data.tar.gz: b1caad27952e66468718b4f070b125c565fb39cb
 SHA512:
-  metadata.gz: 8ac1f9e2374f8aeddaeb1c22640183279e78665e5576650367ff6a1474e96113dd4c22e03899d34829b2ad3bbdbbc916189e153434734a94e52becb1c6f5bc35
-  data.tar.gz: 9b42e020507260c37d906112bfbc99945c077a9546857ef41858d55c86cc069fe0abec4ffb816957f9d78cdecef24edb13738ee3cdd35b26e25ce8af14b6b519
+  metadata.gz: d0d4d2fc97519b154413f07dc2f379ca88f3f21dc5fa5b7f87e1354386f725a47edaf20169b88a1a721e8ababd46dfb11bf8d13f057157f8122c39f332af2649
+  data.tar.gz: 354e6e31fc84edc91190a733c9c99a15d0a84be9d003e44ed951df18c70ce911d1380356930d85f8d281c99afeae71068ae9226af554fef0899271c5d73fd22c

data/README.md

@@ -415,10 +415,30 @@ record.ratings # {:quality=>3}
 
 ## Include linked resources
 
-When fetching records, you can specify in advance all the linked resources that you want to include in the results. With `includes`, LHS ensures that all matching and explicitly linked resources are loaded and merged, if they're included in the server response.
+When fetching records, you can specify in advance all the linked resources that you want to include in the results. With `includes` or `includes_all` (to enforce fetching all remote objects for paginated endpoints), LHS ensures that all matching and explicitly linked resources are loaded and merged.
 
 The implementation is heavily influenced by [http://guides.rubyonrails.org/active_record_class_querying](http://guides.rubyonrails.org/active_record_class_querying.html#eager-loading-associations) and you should read it to understand this feature in all its glory.
 
+### `includes_all` for paginated endpoints
+
+In case endpoints are paginated and you are certain that you'll need all objects of a set and not only the first page/batch, use `includes_all`.
+
+LHS will ensure that all linked resources are around by loading all pages (parallelized/performance optimized).
+
+```ruby
+customer = Customer.includes_all(contracts: :products).find(1)
+
+# GET http://datastore/customers/1
+# GET http://datastore/customers/1/contracts?limit=100
+# GET http://datastore/customers/1/contracts?limit=10&offset=10
+# GET http://datastore/customers/1/contracts?limit=10&offset=20
+# GET http://datastore/products?limit=100
+# GET http://datastore/products?limit=10&offset=10
+
+customer.contracts.length # 33
+customer.contracts.first.products.length # 22
+```
+
 ### One-Level `includes`
 
 ```ruby

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

@@ -11,10 +11,12 @@ class LHS::Record
       # compute the amount of left over requests, do all the the left over requests
       # for the following pages and concatenate all the results in order to return
       # all the objects for a given resource.
-      def all(params = {})
-        limit = params[limit_key] || LHS::Pagination::DEFAULT_LIMIT
-        data = request(params: params.merge(limit_key => limit))
-        request_all_the_rest(data, params) if paginated?(data._raw)
+      def all(options = {})
+        options ||= {}
+        options[:params] ||= {}
+        options[:params] = options[:params].merge(limit_key => options[:params][limit_key] || LHS::Pagination::Base::DEFAULT_LIMIT)
+        data = request(options)
+        load_and_merge_all_the_rest!(data, options) if paginated?(data._raw)
         data._record.new(LHS::Data.new(data, nil, self))
       end
 
@@ -32,26 +34,64 @@ class LHS::Record
         end
       end
 
-      def request_all_the_rest(data, params)
+      # After fetching the first page,
+      # we can evaluate if there are further remote objects remaining
+      # and after preparing all the requests that have to be made in order to fetch all
+      # remote items during this batch, they are fetched in parallel
+      def load_and_merge_all_the_rest!(data, options)
+        if paginated?(data._raw)
+          load_and_merge_paginated_collection!(data, options)
+        elsif data.collection? && paginated?(data.first._raw)
+          load_and_merge_set_of_paginated_collections!(data, options)
+        end
+      end
+
+      def load_and_merge_paginated_collection!(data, options)
         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 => 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
+        return data if pagination.pages_left.zero?
+        record = data._record
+        record.request(
+          options_for_next_batch(record, pagination, options)
+        ).each do |batch_data|
+          merge_batch_data_with_parent!(batch_data, data)
+        end
+      end
+
+      def load_and_merge_set_of_paginated_collections!(data, options)
+        options_for_this_batch = []
+        options.each_with_index do |_, index|
+          record = data[index]._record
+          pagination = record.pagination(data[index])
+          next if pagination.pages_left.zero?
+          options_for_this_batch.push(options_for_next_batch(record, pagination, options[index], data[index]))
+        end
+        data._record.request(options_for_this_batch.flatten).each do |batch_data|
+          merge_batch_data_with_parent!(batch_data, batch_data._request.options[:parent_data])
+        end
+      end
+
+      def merge_batch_data_with_parent!(batch_data, parent_data)
+        parent_data._raw[items_key].concat all_items_from batch_data
+        parent_data._raw[limit_key] = batch_data._raw[limit_key]
+        parent_data._raw[total_key] = batch_data._raw[total_key]
+        parent_data._raw[pagination_key] = batch_data._raw[pagination_key]
+      end
+
+      def options_for_next_batch(record, pagination, options, parent_data = nil)
+        batch_options = []
+        pagination.pages_left.times do |index|
+          page_options = {
+            params: {
+              record.limit_key => pagination.limit,
+              record.pagination_key => pagination.next_offset(index + 1)
+            }
+          }
+          page_options[:parent_data] = parent_data if parent_data
+          batch_options.push(
+            options.deep_dup.deep_merge(page_options)
+          )
         end
+        batch_options
       end
     end
   end

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

@@ -20,7 +20,7 @@ class LHS::Record
       def find_in_batches(options = {})
         raise 'No block given' unless block_given?
         start = options[:start] || 1
-        batch_size = options[:batch_size] || LHS::Pagination::DEFAULT_LIMIT
+        batch_size = options[:batch_size] || LHS::Pagination::Base::DEFAULT_LIMIT
         params = options[:params] || {}
         loop do # as suggested by Matz
           data = request(params: params.merge(limit_key => batch_size, pagination_key => start))

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

@@ -39,6 +39,12 @@ class LHS::Record
         Chain.new(self, Include.new(Chain.unfold(args)))
       end
 
+      def includes_all(*args)
+        chain = Chain.new(self, Include.new(Chain.unfold(args)))
+        chain.include_all!(args)
+        chain
+      end
+
       def references(*args)
         Chain.new(self, Reference.new(Chain.unfold(args)))
       end
@@ -162,36 +168,42 @@ class LHS::Record
       alias validate valid?
 
       def where(hash = nil)
-        push Parameter.new(hash)
+        push(Parameter.new(hash))
       end
 
       def options(hash = nil)
-        push Option.new(hash)
+        push(Option.new(hash))
       end
 
       def page(page)
-        push Pagination.new(page: page)
+        push(Pagination.new(page: page))
       end
 
       def per(per)
-        push Pagination.new(per: per)
+        push(Pagination.new(per: per))
       end
 
       def limit(argument = nil)
         return resolve.limit if argument.blank?
-        push Pagination.new(per: argument)
+        push(Pagination.new(per: argument))
       end
 
       def handle(error_class, handler)
-        push ErrorHandling.new(error_class => handler)
+        push(ErrorHandling.new(error_class => handler))
       end
 
       def includes(*args)
-        push Include.new(Chain.unfold(args))
+        push(Include.new(Chain.unfold(args)))
+      end
+
+      def includes_all(*args)
+        chain = push(Include.new(Chain.unfold(args)))
+        chain.include_all!(args)
+        chain
       end
 
       def references(*args)
-        push Reference.new(Chain.unfold(args))
+        push(Reference.new(Chain.unfold(args)))
       end
 
       def find(*args)
@@ -235,6 +247,14 @@ class LHS::Record
         chain_references
       end
 
+      # Adds additional .references(name_of_linked_resource: { all: true })
+      # to all linked resources included with includes_all
+      def include_all!(args)
+        includes_all_to_references(args).each do |reference|
+          _links.push(reference)
+        end
+      end
+
       protected
 
       def method_missing(name, *args, &block)
@@ -265,6 +285,42 @@ class LHS::Record
 
       private
 
+      # Translates includes_all(resources:) to the internal datastructure
+      # references(resource: { all: true })
+      def includes_all_to_references(args, parent = nil)
+        references = []
+        if args.is_a?(Array)
+          includes_all_to_references_for_arrays!(references, args, parent)
+        elsif args.is_a?(Hash)
+          includes_all_to_references_for_hash!(references, args, parent)
+        elsif args.is_a?(Symbol)
+          includes_all_to_references_for_symbol!(references, args, parent)
+        end
+        references
+      end
+
+      def includes_all_to_references_for_arrays!(references, args, parent)
+        args.each do |part|
+          references.concat(includes_all_to_references(part, parent))
+        end
+      end
+
+      def includes_all_to_references_for_hash!(references, args, parent)
+        args.each do |key, value|
+          parent ||= { all: true }
+          references.concat([Reference.new(key => parent)])
+          references.concat(includes_all_to_references(value, parent))
+        end
+      end
+
+      def includes_all_to_references_for_symbol!(references, args, parent)
+        if parent.present?
+          parent[args] = { all: true }
+        else
+          references.concat([Reference.new(args => { all: true })])
+        end
+      end
+
       def push(link)
         clone = self.clone
         clone._links = _links + [link].compact
@@ -306,7 +362,7 @@ class LHS::Record
       def resolve_pagination(links)
         return {} if links.empty?
         page = 1
-        per = LHS::Pagination::DEFAULT_LIMIT
+        per = LHS::Pagination::Base::DEFAULT_LIMIT
         links.each do |link|
           page = link[:page] if link[:page].present?
           per = link[:per] if link[:per].present?

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

@@ -15,11 +15,11 @@ class LHS::Record
       def pagination_class
         case pagination_strategy.to_sym
         when :page
-          LHS::PagePagination
+          LHS::Pagination::Page
         when :start
-          LHS::StartPagination
+          LHS::Pagination::Start
         else
-          LHS::OffsetPagination
+          LHS::Pagination::Offset
         end
       end
 

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

@@ -8,6 +8,7 @@ class LHS::Record
     module ClassMethods
       def request(options)
         options ||= {}
+        options = options.deep_dup
         if options.is_a? Array
           multiple_requests(options)
         else
@@ -164,17 +165,66 @@ class LHS::Record
         record = record_for_options(options) || self
         options = convert_options_to_endpoints(options) if record_for_options(options)
         begin
-          if options.is_a?(Array)
-            options.each { |options| options.merge!(including: sub_includes, referencing: references) if sub_includes.present? }
-          elsif sub_includes.present?
-            options.merge!(including: sub_includes, referencing: references)
+          prepare_options_for_include_request!(options, sub_includes, references)
+          if references && references[:all] # include all linked resources
+            prepare_options_for_include_all_request!(options)
+            data = load_all_included!(record, options)
+            references.delete(:all) # for this all remote objects have been fetched
+            continue_including(data, sub_includes, references)
+          else # simply request first page/batch
+            data = record.request(options)
+            warn "[WARNING] You included `#{options[:url]}`, but this endpoint is paginated. You might want to use `includes_all` instead of `includes` (https://github.com/local-ch/lhs#includes_all-for-paginated-endpoints)." if paginated?(data._raw)
+            data
           end
-          record.request(options)
         rescue LHC::NotFound
           LHS::Data.new({}, data, record)
         end
       end
 
+      # Continues loading included resources after one complete batch/level has been fetched
+      def continue_including(data, including, referencing)
+        handle_includes(including, data, referencing) if including.present? && data.present?
+        data
+      end
+
+      # Loads all included/linked resources,
+      # paginates itself to ensure all records are fetched
+      def load_all_included!(record, options)
+        data = record.request(options)
+        load_and_merge_all_the_rest!(data, options)
+        data
+      end
+
+      def prepare_options_for_include_all_request!(options)
+        if options.is_a?(Array)
+          options.each do |option|
+            prepare_option_for_include_all_request!(option)
+          end
+        else
+          prepare_option_for_include_all_request!(options)
+        end
+        options
+      end
+
+      # When including all resources on one level, don't forward :includes & :references
+      # as we have to fetch all resources on this level first, before we continue_including
+      def prepare_option_for_include_all_request!(option)
+        option[:params] ||= {}
+        option[:params].merge!(limit_key => option.fetch(:params, {}).fetch(limit_key, LHS::Pagination::Base::DEFAULT_LIMIT))
+        option.delete(:including)
+        option.delete(:referencing)
+        option
+      end
+
+      def prepare_options_for_include_request!(options, sub_includes, references)
+        if options.is_a?(Array)
+          options.each { |option| option.merge!(including: sub_includes, referencing: references) if sub_includes.present? }
+        elsif sub_includes.present?
+          options.merge!(including: sub_includes, referencing: references)
+        end
+        options || {}
+      end
+
       # Merge explicit params nested in 'params' namespace with original hash.
       def merge_explicit_params!(params)
         return true unless params
@@ -195,7 +245,7 @@ class LHS::Record
         referencing = LHS::Complex.reduce options.compact.map { |options| options.delete(:referencing) }.compact
         data = restore_with_nils(data, locate_nils(options)) # nil objects in data provide location information for mapping
         data = LHS::Data.new(data, nil, self)
-        handle_includes(including, data, referencing) if including.present? && !data.empty?
+        handle_includes(including, data, referencing) if including.present? && data.present?
         data
       end
 
@@ -274,7 +324,7 @@ class LHS::Record
         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, referencing) if including
+        handle_includes(including, data, referencing) if including.present? && data.present?
         data
       end
 

data/lib/lhs/pagination/base.rb

@@ -0,0 +1,81 @@
+# Pagination is used to navigate paginateable collections
+module LHS::Pagination
+  class Base
+
+    DEFAULT_LIMIT = 100
+
+    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] || DEFAULT_LIMIT
+    end
+
+    def offset
+      data._raw[_record.pagination_key.to_sym].presence || 0
+    end
+    alias current_page offset
+    alias start offset
+
+    def pages_left
+      total_pages - current_page
+    end
+
+    def next_offset(_step = 1)
+      raise 'to be implemented in subclass'
+    end
+
+    def current_page
+      raise 'to be implemented in subclass'
+    end
+
+    def first_page
+      1
+    end
+
+    def last_page
+      total_pages
+    end
+
+    def next?
+      data._raw[:next].present?
+    end
+
+    def previous?
+      data._raw[:previous].present?
+    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
+
+    def self.page_to_offset(page, _limit)
+      page.to_i
+    end
+  end
+end

data/lib/lhs/pagination/offset.rb

@@ -0,0 +1,14 @@
+class LHS::Pagination::Offset < LHS::Pagination::Base
+
+  def current_page
+    (offset + limit) / limit
+  end
+
+  def next_offset(step = 1)
+    offset + limit * step
+  end
+
+  def self.page_to_offset(page, limit = DEFAULT_LIMIT)
+    (page.to_i - 1) * limit.to_i
+  end
+end

data/lib/lhs/pagination/page.rb

@@ -0,0 +1,10 @@
+class LHS::Pagination::Page < LHS::Pagination::Base
+
+  def current_page
+    offset
+  end
+
+  def next_offset(step = 1)
+    current_page + step
+  end
+end

data/lib/lhs/pagination/start.rb

@@ -0,0 +1,14 @@
+class LHS::Pagination::Start < LHS::Pagination::Base
+
+  def current_page
+    (offset + limit - 1) / limit
+  end
+
+  def next_offset(step = 1)
+    offset + limit * step
+  end
+
+  def self.page_to_offset(page, limit = DEFAULT_LIMIT)
+    (page.to_i - 1) * limit.to_i + 1
+  end
+end

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = "7.4.1"
+  VERSION = "8.0.0"
 end

data/spec/collection/configurable_spec.rb

@@ -31,7 +31,7 @@ describe LHS::Collection do
 
   context 'lets you configure how to deal with collections' do
     it 'initalises and gives access to collections according to configuration' do
-      results = Search.all(type: :phonebook, size: 10)
+      results = Search.all(params: { type: :phonebook, size: 10 })
       expect(results.count).to eq total
       expect(results.total).to eq total
       expect(results.limit).to eq limit

data/spec/pagination/pages_left_spec.rb

@@ -8,7 +8,7 @@ describe LHS::Record do
     LHS::Data.new(data_hash, nil, Record)
   end
 
-  let(:pagination) { LHS::OffsetPagination.new(data) }
+  let(:pagination) { LHS::Pagination::Offset.new(data) }
 
   before(:each) do
     class Record < LHS::Record

data/spec/record/includes_all_spec.rb

@@ -0,0 +1,119 @@
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'includes all' do
+    before(:each) do
+      class Customer < LHS::Record
+        endpoint 'http://datastore/customers/:id'
+      end
+    end
+
+    let(:amount_of_contracts) { 33 }
+    let(:amount_of_products) { 22 }
+
+    let!(:customer_request) do
+      stub_request(:get, 'http://datastore/customers/1')
+        .to_return(
+          body: {
+            contracts: { href: 'http://datastore/customers/1/contracts' }
+          }.to_json
+        )
+    end
+
+    let!(:contracts_request) do
+      stub_request(:get, "http://datastore/customers/1/contracts?limit=100")
+        .to_return(
+          body: {
+            items: 10.times.map do
+              {
+                products: { href: 'http://datastore/products' }
+              }
+            end,
+            limit: 10,
+            offset: 0,
+            total: amount_of_contracts
+          }.to_json
+        )
+    end
+
+    def additional_contracts_request(offset, amount)
+      stub_request(:get, "http://datastore/customers/1/contracts?limit=10&offset=#{offset}")
+        .to_return(
+          body: {
+            items: amount.times.map do
+              {
+                products: { href: 'http://datastore/products' }
+              }
+            end,
+            limit: 10,
+            offset: offset,
+            total: amount_of_contracts
+          }.to_json
+        )
+    end
+
+    let!(:contracts_request_page_2) do
+      additional_contracts_request(10, 10)
+    end
+
+    let!(:contracts_request_page_3) do
+      additional_contracts_request(20, 10)
+    end
+
+    let!(:contracts_request_page_4) do
+      additional_contracts_request(30, 3)
+    end
+
+    let!(:products_request) do
+      stub_request(:get, "http://datastore/products?limit=100")
+        .to_return(
+          body: {
+            items: 10.times.map do
+              { name: 'LBC' }
+            end,
+            limit: 10,
+            offset: 0,
+            total: amount_of_products
+          }.to_json
+        )
+    end
+
+    def additional_products_request(offset, amount)
+      stub_request(:get, "http://datastore/products?limit=10&offset=#{offset}")
+        .to_return(
+          body: {
+            items: amount.times.map do
+              { name: 'LBC' }
+            end,
+            limit: 10,
+            offset: offset,
+            total: amount_of_products
+          }.to_json
+        )
+    end
+
+    let!(:products_request_page_2) do
+      additional_products_request(10, 10)
+    end
+
+    let!(:products_request_page_3) do
+      additional_products_request(20, 2)
+    end
+
+    it 'includes all linked business objects no matter pagination' do
+      customer = Customer
+        .includes_all(contracts: :products)
+        .find(1)
+      expect(customer.contracts.length).to eq amount_of_contracts
+      expect(customer.contracts.first.products.length).to eq amount_of_products
+      expect(customer_request).to have_been_requested.at_least_once
+      expect(contracts_request).to have_been_requested.at_least_once
+      expect(contracts_request_page_2).to have_been_requested.at_least_once
+      expect(contracts_request_page_3).to have_been_requested.at_least_once
+      expect(contracts_request_page_4).to have_been_requested.at_least_once
+      expect(products_request).to have_been_requested.at_least_once
+      expect(products_request_page_2).to have_been_requested.at_least_once
+      expect(products_request_page_3).to have_been_requested.at_least_once
+    end
+  end
+end

data/spec/record/includes_warning_spec.rb

@@ -0,0 +1,44 @@
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'includes warning' do
+    before(:each) do
+      class Customer < LHS::Record
+        endpoint 'http://datastore/customers/:id'
+      end
+    end
+
+    let!(:customer_request) do
+      stub_request(:get, 'http://datastore/customers/1')
+        .to_return(
+          body: {
+            contracts: { href: 'http://datastore/customers/1/contracts' }
+          }.to_json
+        )
+    end
+
+    let!(:contracts_request) do
+      stub_request(:get, "http://datastore/customers/1/contracts")
+        .to_return(
+          body: {
+            items: 10.times.map do
+              {
+                products: { href: 'http://datastore/products' }
+              }
+            end,
+            limit: 10,
+            offset: 0,
+            total: 33
+          }.to_json
+        )
+    end
+
+    it 'warns if linked data was simply included but is paginated' do
+      expect(lambda {
+        Customer.includes(:contracts).find(1)
+      }).to output(
+        "[WARNING] You included `http://datastore/customers/1/contracts`, but this endpoint is paginated. You might want to use `includes_all` instead of `includes` (https://github.com/local-ch/lhs#includes_all-for-paginated-endpoints).\n"
+      ).to_stderr
+    end
+  end
+end

data/spec/record/paginatable_collection_spec.rb

@@ -16,7 +16,12 @@ describe LHS::Record do
       stub_request(:get, "#{datastore}/feedbacks?limit=100")
         .to_return(
           status: 200,
-          body: { items: [], total: 300, offset: 0 }.to_json
+          body: { items: [], total: 200, offset: 0 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=100")
+        .to_return(
+          status: 200,
+          body: { items: [], total: 200, offset: 0 }.to_json
         )
       all = Record.all
       expect(all).to be_kind_of Record

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 7.4.1
+  version: 8.0.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
@@ -225,7 +225,10 @@ files:
 - lib/lhs/endpoint.rb
 - lib/lhs/errors.rb
 - lib/lhs/item.rb
-- lib/lhs/pagination.rb
+- lib/lhs/pagination/base.rb
+- lib/lhs/pagination/offset.rb
+- lib/lhs/pagination/page.rb
+- lib/lhs/pagination/start.rb
 - lib/lhs/proxy.rb
 - lib/lhs/record.rb
 - lib/lhs/version.rb
@@ -329,7 +332,9 @@ files:
 - spec/record/find_spec.rb
 - spec/record/first_spec.rb
 - spec/record/immutable_chains_spec.rb
+- spec/record/includes_all_spec.rb
 - spec/record/includes_spec.rb
+- spec/record/includes_warning_spec.rb
 - spec/record/loading_twice_spec.rb
 - spec/record/mapping_spec.rb
 - spec/record/model_name_spec.rb
@@ -483,7 +488,9 @@ test_files:
 - spec/record/find_spec.rb
 - spec/record/first_spec.rb
 - spec/record/immutable_chains_spec.rb
+- spec/record/includes_all_spec.rb
 - spec/record/includes_spec.rb
+- spec/record/includes_warning_spec.rb
 - spec/record/loading_twice_spec.rb
 - spec/record/mapping_spec.rb
 - spec/record/model_name_spec.rb

data/lib/lhs/pagination.rb

@@ -1,120 +0,0 @@
-# Pagination is used to navigate paginateable collections
-class LHS::Pagination
-
-  DEFAULT_LIMIT = 100
-
-  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::Pagination::DEFAULT_LIMIT
-  end
-
-  def offset
-    data._raw[_record.pagination_key.to_sym].presence || 0
-  end
-  alias current_page offset
-  alias start offset
-
-  def pages_left
-    total_pages - current_page
-  end
-
-  def next_offset
-    raise 'to be implemented in subclass'
-  end
-
-  def current_page
-    raise 'to be implemented in subclass'
-  end
-
-  def first_page
-    1
-  end
-
-  def last_page
-    total_pages
-  end
-
-  def next?
-    data._raw[:next].present?
-  end
-
-  def previous?
-    data._raw[:previous].present?
-  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
-
-  def self.page_to_offset(page, _limit)
-    page.to_i
-  end
-end
-
-class LHS::PagePagination < LHS::Pagination
-
-  def current_page
-    offset
-  end
-
-  def next_offset
-    current_page + 1
-  end
-end
-
-class LHS::StartPagination < LHS::Pagination
-
-  def current_page
-    (offset + limit - 1) / limit
-  end
-
-  def next_offset
-    offset + limit
-  end
-
-  def self.page_to_offset(page, limit = LHS::Pagination::DEFAULT_LIMIT)
-    (page.to_i - 1) * limit.to_i + 1
-  end
-end
-
-class LHS::OffsetPagination < LHS::Pagination
-
-  def current_page
-    (offset + limit) / limit
-  end
-
-  def next_offset
-    offset + limit
-  end
-
-  def self.page_to_offset(page, limit = LHS::Pagination::DEFAULT_LIMIT)
-    (page.to_i - 1) * limit.to_i
-  end
-end