ruby-lokalise-api 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2212a93b34d63ef5bec7884f3003088d74a2c616affdf9931ad9767ae8b1f5d
-  data.tar.gz: e56cee6b0d8bc2974591f215191a1543f2d1b9d28a774b46c7bec1fff96c5ccb
+  metadata.gz: 5258f1c07fdb9ffa68ab473b4bddf714f42874a049fa6657f1c3791f3cad3f6b
+  data.tar.gz: '05957d96074c503f46c49fb0a88292e6b5a30248c643d094b5dbabfa51dbb7b3'
 SHA512:
-  metadata.gz: ec48688594d2492bade883ac5dda7baa533d9f27a6c7cd59dc90cfd30e7be5e8517885f85ca3a43b3d8009bd8052945334a4c38dcee60a1a4720960289e4e338
-  data.tar.gz: 2c367579e4617dc4c89474afbd09b7b62b10a768ddaca01162934527e3211391f225ea39d3cc1a8fa1310c661d9eaab758c8239a887c2d7e091c0f4152211be0
+  metadata.gz: 5539b8cf6ab910c93ffe47b1ffd1b47ac4d323c971560d869fdf7dd0531e81b2312bbc45f1d4c6ea3d30af4fd451726bd14333a440bec0d8fb85ffc5c30caa62
+  data.tar.gz: c02b44af1ca82999d596e278fa65c7831590080f64168ab16b7d9f407e04087fdbe92e4d7177ab41bb56cedde30624277dce8fb2bf22873439c9160372bf83a4

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.1.0
+
+* Added methods to work with pagination (`next_page?`, `last_page?`, `prev_page?`, `first_page?`, `next_page`, `prev_page`)
+
+## 1.0.1 (10-Dec-18)
+
+* Fixed incorrect build
+
 ## 1.0.0 (10-Dec-18)
 
 * Initial release

data/README.md

@@ -99,11 +99,29 @@ Collections respond to the following methods:
 * `#total_results`
 * `#results_per_page`
 * `#current_page`
+* `#next_page?`
+* `#last_page?`
+* `#prev_page?`
+* `#first_page?`
 
 For example:
 
 ```ruby
 projects.current_page #=> 3
+projects.last_page? #=> true, this is the last page and there are no more projects available
+```
+
+On top of that, you may easily fetch the next or the previous page of the collection by using:
+
+* `#next_page`
+* `#prev_page`
+
+These methods return instances of the same collection class or `nil` if the next/previous page is unavailable. Methods respect the parameters you've initially passed:
+
+```ruby
+translations = @client.translations 'project_id', limit: 4, page: 2, disable_references: 0 # => we passed three parameters here
+
+translations.prev_page # => will load the previous page while preserving the `limit` and `disable_references` params
 ```
 
 ## Available Resources

data/lib/ruby-lokalise-api/collections/base.rb

@@ -5,29 +5,81 @@ module Lokalise
       extend Lokalise::Utils::AttributeHelpers
       include Lokalise::Utils::AttributeHelpers
 
-      attr_reader :raw_data, :total_pages, :total_results, :results_per_page, :current_page, :collection,
-                  :project_id, :team_id
+      attr_reader :total_pages, :total_results, :results_per_page, :current_page, :collection,
+                  :project_id, :team_id, :request_params, :client, :ids
 
-      def initialize(response)
+      # Initializes a new collection based on the response
+      #
+      # @param response [Hash]
+      # @param params [Hash]
+      # @param ids [Array, Integer, String]
+      # @return [Lokalise::Collections::Base]
+      def initialize(response, params = {}, *ids)
         produce_collection_for response
-        @total_results = response['x-pagination-total-count'].to_i
-        @total_pages = response['x-pagination-page-count'].to_i
-        @results_per_page = response['x-pagination-limit'].to_i
-        @current_page = response['x-pagination-page'].to_i
+        populate_pagination_data_for response
         # Project and team id may not be present in some cases
         @project_id = response['content']['project_id']
         @team_id = response['content']['team_id']
+        @request_params = params
+        @client = response['client']
+        @ids = ids
       end
 
       class << self
         # Performs a batch query fetching multiple records
         def all(client, params = {}, *ids)
-          new get(endpoint(*ids), client, params)
+          new get(endpoint(*ids), client, params),
+              params, *ids
         end
       end
 
+      # @return [Boolean]
+      def next_page?
+        @current_page.positive? && @current_page < @total_pages
+      end
+
+      # @return [Boolean]
+      def last_page?
+        !next_page?
+      end
+
+      # @return [Boolean]
+      def prev_page?
+        @current_page > 1
+      end
+
+      # @return [Boolean]
+      def first_page?
+        !prev_page?
+      end
+
+      def next_page
+        return nil if last_page?
+
+        fetch_page @current_page + 1
+      end
+
+      def prev_page
+        return nil if first_page?
+
+        fetch_page @current_page - 1
+      end
+
       private
 
+      def populate_pagination_data_for(response)
+        @total_results = response['x-pagination-total-count'].to_i
+        @total_pages = response['x-pagination-page-count'].to_i
+        @results_per_page = response['x-pagination-limit'].to_i
+        @current_page = response['x-pagination-page'].to_i
+      end
+
+      def fetch_page(page_num)
+        self.class.all @client,
+                       @request_params.merge(page: page_num),
+                       *@ids
+      end
+
       # Dynamically produces collection of resources based on the given response
       # Collection example: `{ "content": {"comments": [ ... ]} }`
       def produce_collection_for(response)

data/lib/ruby-lokalise-api/request.rb

@@ -39,7 +39,7 @@ module Lokalise
     private
 
     def prepare(path)
-      path.gsub /\/\//, '/'
+      path.gsub %r{//}, '/'
     end
 
     def respond_with(response, client)
@@ -47,8 +47,9 @@ module Lokalise
       respond_with_error(response.status, body) if body.respond_to?(:has_key?) && body.key?('error')
       response.
         headers.
+        to_h.
         keep_if { |k, _v| PAGINATION_HEADERS.include?(k) }.
-        merge(content: body, client: client)
+        merge('content' => body, 'client' => client)
     end
 
     def respond_with_error(code, body)

data/lib/ruby-lokalise-api/resources/base.rb

@@ -7,6 +7,10 @@ module Lokalise
 
       attr_reader :raw_data, :project_id, :client
 
+      # Initializes a new resource based on the response
+      #
+      # @param response [Hash]
+      # @return [Lokalise::Resources::Base]
       def initialize(response)
         populate_attributes_for response['content']
 
@@ -42,7 +46,7 @@ module Lokalise
                           client,
                           body_from(params, object_key))
 
-          object_from response
+          object_from response, params, endpoint_ids
         end
 
         # Updates one or multiple records
@@ -51,7 +55,7 @@ module Lokalise
                          client,
                          body_from(params, object_key))
 
-          object_from response
+          object_from response, params, endpoint_ids
         end
 
         # Destroys records by given ids
@@ -83,12 +87,14 @@ module Lokalise
         end
 
         # Instantiates a new resource or collection based on the given response
-        def object_from(response)
+        def object_from(response, params, endpoint_ids)
           model_class = name.base_class_name
           data_key_plural = data_key_for model_class, true
 
           if response['content'].key? data_key_plural
-            Module.const_get("Lokalise::Collections::#{model_class}").new response
+            Module.const_get("Lokalise::Collections::#{model_class}").new response,
+                                                                          params,
+                                                                          endpoint_ids
           else
             new response
           end

data/lib/ruby-lokalise-api/version.rb

@@ -1,3 +1,3 @@
 module Lokalise
-  VERSION = '1.0.1'.freeze
+  VERSION = '1.1.0'.freeze
 end

data/spec/lib/ruby-lokalise-api/rest/comments_spec.rb

@@ -22,6 +22,14 @@ RSpec.describe Lokalise::Client do
       expect(comments.results_per_page).to eq(1)
       expect(comments.current_page).to eq(2)
       expect(comments.collection.first.comment).to eq('demo comment')
+
+      expect(comments.next_page?).to eq(true)
+      expect(comments.last_page?).to eq(false)
+      expect(comments.prev_page?).to eq(true)
+      expect(comments.first_page?).to eq(false)
+
+      expect(comments.ids).to include(project_id, key_id)
+      expect(comments.client).to be_an_instance_of(Lokalise::Client)
     end
   end
 

data/spec/lib/ruby-lokalise-api/rest/contributors_spec.rb

@@ -22,6 +22,11 @@ RSpec.describe Lokalise::Client do
       expect(contributors.total_pages).to eq(2)
       expect(contributors.results_per_page).to eq(1)
       expect(contributors.current_page).to eq(2)
+
+      expect(contributors.next_page?).to eq(false)
+      expect(contributors.last_page?).to eq(true)
+      expect(contributors.prev_page?).to eq(true)
+      expect(contributors.first_page?).to eq(false)
     end
   end
 

data/spec/lib/ruby-lokalise-api/rest/files_spec.rb

@@ -24,6 +24,9 @@ RSpec.describe Lokalise::Client do
       expect(files.total_pages).to eq(1)
       expect(files.results_per_page).to eq(1)
       expect(files.current_page).to eq(1)
+
+      expect(files.next_page).to be_nil
+      expect(files.prev_page).to be_nil
     end
   end
 

data/spec/lib/ruby-lokalise-api/rest/keys_spec.rb

@@ -22,6 +22,11 @@ RSpec.describe Lokalise::Client do
       expect(keys.total_pages).to eq(1)
       expect(keys.results_per_page).to eq(1)
       expect(keys.current_page).to eq(1)
+
+      expect(keys.next_page?).to eq(false)
+      expect(keys.last_page?).to eq(true)
+      expect(keys.prev_page?).to eq(false)
+      expect(keys.first_page?).to eq(true)
     end
   end
 
@@ -85,10 +90,14 @@ RSpec.describe Lokalise::Client do
           tags: %w[bulk upd]
         }
       ]
-    end.collection
+    end
+
+    # `update_keys` returns a collection but it should not be paginated
+    expect(keys.next_page?).to eq(false)
+    expect(keys.prev_page?).to eq(false)
 
-    first_key = keys.first
-    second_key = keys[1]
+    first_key = keys.collection.first
+    second_key = keys.collection[1]
 
     expect(first_key.key_id).to eq(key_id)
     expect(first_key.key_name['ios']).to eq('test')

data/spec/lib/ruby-lokalise-api/rest/projects_spec.rb

@@ -22,6 +22,11 @@ RSpec.describe Lokalise::Client do
       expect(projects.total_pages).to eq(5)
       expect(projects.results_per_page).to eq(1)
       expect(projects.current_page).to eq(2)
+
+      expect(projects.next_page?).to eq(true)
+      expect(projects.last_page?).to eq(false)
+      expect(projects.prev_page?).to eq(true)
+      expect(projects.first_page?).to eq(false)
     end
   end
 

data/spec/lib/ruby-lokalise-api/rest/snapshots_spec.rb

@@ -28,6 +28,11 @@ RSpec.describe Lokalise::Client do
       expect(snapshots.total_pages).to eq(2)
       expect(snapshots.results_per_page).to eq(1)
       expect(snapshots.current_page).to eq(2)
+
+      expect(snapshots.next_page?).to eq(false)
+      expect(snapshots.last_page?).to eq(true)
+      expect(snapshots.prev_page?).to eq(true)
+      expect(snapshots.first_page?).to eq(false)
     end
   end
 

data/spec/lib/ruby-lokalise-api/rest/translations_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe Lokalise::Client do
 
     it 'should support pagination' do
       translations = VCR.use_cassette('all_translations_pagination') do
-        test_client.translations project_id, limit: 4, page: 2
+        test_client.translations project_id, limit: 4, page: 2, disable_references: 0
       end
 
       expect(translations.collection.count).to eq(4)
@@ -21,6 +21,37 @@ RSpec.describe Lokalise::Client do
       expect(translations.total_pages).to eq(3)
       expect(translations.results_per_page).to eq(4)
       expect(translations.current_page).to eq(2)
+      expect(translations.request_params[:page]).to eq(2)
+      expect(translations.request_params[:disable_references]).to eq(0)
+      expect(translations.ids).to eq([project_id])
+
+      next_page_trans = VCR.use_cassette('translations_next_page') do
+        translations.next_page
+      end
+
+      expect(next_page_trans).to be_an_instance_of(Lokalise::Collections::Translation)
+      expect(next_page_trans.client).to be_an_instance_of(Lokalise::Client)
+      expect(next_page_trans.request_params[:page]).to eq(3)
+      expect(next_page_trans.request_params[:disable_references]).to eq(0)
+      expect(next_page_trans.total_results).to eq(9)
+      expect(next_page_trans.current_page).to eq(3)
+      expect(next_page_trans.ids).to eq([project_id])
+      expect(next_page_trans.next_page?).to eq(false)
+      expect(next_page_trans.prev_page?).to eq(true)
+
+      prev_page_trans = VCR.use_cassette('translations_prev_page') do
+        translations.prev_page
+      end
+
+      expect(prev_page_trans).to be_an_instance_of(Lokalise::Collections::Translation)
+      expect(prev_page_trans.client).to be_an_instance_of(Lokalise::Client)
+      expect(prev_page_trans.request_params[:page]).to eq(1)
+      expect(next_page_trans.request_params[:disable_references]).to eq(0)
+      expect(prev_page_trans.total_results).to eq(9)
+      expect(prev_page_trans.current_page).to eq(1)
+      expect(prev_page_trans.next_page?).to eq(true)
+      expect(prev_page_trans.prev_page?).to eq(false)
+      expect(prev_page_trans.ids).to eq([project_id])
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lokalise-api
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Ilya Bodrov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-10 00:00:00.000000000 Z
+date: 2018-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday