laziness 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4575bffe5cbe1205a7f1b3057d607983b68f5cf821d7d85b45c4e6ef336dc28a
-  data.tar.gz: a4e88867662053bbf3cf63741a85b9985107c3574a1328eeb8c594c7210f6aaa
+  metadata.gz: a76e439503c65d13c7c8ab8f00bdc5ee3d22dc06d60acf0ae8fe959808e63133
+  data.tar.gz: e6297370c3f3f22f01b468844d4ae79a3cd20e691c27d95e7471cc645133c66a
 SHA512:
-  metadata.gz: a7d62f72f2c7856fbb300bab0802dc19cc77c531691fca086b5c0cab67c50032003d388aa47658b67ae962fb0f400f2311f96c544ed2b8ef0b497fc2fd391221
-  data.tar.gz: 67b0f5bc0f81deda62afa7a06239db6fb90b512b5cc6efc991c73ab90dee5afebf83c317b2a6241c98382e8bd8ea6d3c044193abba4da688a62be7b107ce6b55
+  metadata.gz: de5a77da3465d2a5a6ce098539c6802d515e6a57c1d88aafde8345f42448c747f0512bd6ead50c101a7ddbf90bc85bca5e65049059cfeb6e0989485eb60ecae1
+  data.tar.gz: 6f1b839c1a7d8235376564141a5323b050606870bd6907fa6909d57bbb77f1a1e4037c7937dcd798038296746ca458c22bd84d9509d37d2f84164a05a9f89be3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    laziness (0.2.4)
+    laziness (0.2.5)
       eventmachine
       faye-websocket (>= 0.8.0)
       hashie
@@ -10,14 +10,16 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.3.6)
-    crack (0.4.2)
+    addressable (2.6.0)
+      public_suffix (>= 2.0.2, < 4.0)
+    crack (0.4.3)
       safe_yaml (~> 1.0.0)
-    diff-lcs (1.2.5)
+    diff-lcs (1.3)
     eventmachine (1.2.7)
     faye-websocket (0.10.7)
       eventmachine (>= 0.12.0)
       websocket-driver (>= 0.5.1)
+    hashdiff (0.3.8)
     hashie (3.6.0)
     httparty (0.16.4)
       mime-types (~> 3.0)
@@ -26,23 +28,26 @@ GEM
       mime-types-data (~> 3.2015)
     mime-types-data (3.2018.0812)
     multi_xml (0.6.0)
+    public_suffix (3.0.3)
     rake (10.3.2)
-    rspec (3.1.0)
-      rspec-core (~> 3.1.0)
-      rspec-expectations (~> 3.1.0)
-      rspec-mocks (~> 3.1.0)
-    rspec-core (3.1.7)
-      rspec-support (~> 3.1.0)
-    rspec-expectations (3.1.2)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.1.0)
-    rspec-mocks (3.1.3)
-      rspec-support (~> 3.1.0)
-    rspec-support (3.1.2)
-    safe_yaml (1.0.3)
-    webmock (1.18.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    safe_yaml (1.0.5)
+    webmock (3.5.1)
       addressable (>= 2.3.6)
       crack (>= 0.3.2)
+      hashdiff
     websocket-driver (0.7.0)
       websocket-extensions (>= 0.1.0)
     websocket-extensions (0.1.3)

data/README.md

@@ -178,6 +178,20 @@ client.users.find(user_id) # get info about a specific user
 client.users.set_active # sets the current user (defined by the access_token) as active
 ```
 
+### Pagination
+
+In order to support paging, you can provide a `page` parameter to all methods that support paging. If the `page` parameter exists, the method will map until all conversations are retrieved.
+
+```
+conversations = client.conversations.all(page: { limit: 10, sleep_interval: 2, max_retries: 20 })
+```
+
+If you want to limit the number of page retrievals, you can set the `page` parameter to the number of retrievals to retrieve. For example, if you just want to retrieve one page worth of 1000 results, you can do the following:
+
+```
+conversations = client.conversations.all(page: { limit: 1000 })
+```
+
 ## REAL TIME API USAGE
 
 The [Slack Real Time Messaging API](https://api.slack.com/rtm) is made up of Websocket events that allow you to communicate with Slack as a bot (or yourself) with an access token.

data/lib/laziness/api/base.rb

@@ -18,6 +18,12 @@ module Slack
         nil
       end
 
+      def with_paging(page)
+        Cursor.new(page).paginate do |pager|
+          yield(pager)
+        end
+      end
+
       def request(method, path, arguments={})
         full_path = "#{base_path}#{path}"
         full_path = "#{full_path}?token=#{access_token}" unless access_token.nil?
@@ -45,6 +51,8 @@ module Slack
           klass = "#{parsed['error'].gsub(/(^|_)(.)/) { $2.upcase }}Error"
           if Slack.const_defined? klass
             raise Slack.const_get(klass)
+          elsif response.code == 429
+            raise Slack::TooManyRequestsError.new(response)
           else
             raise Slack::APIError.new parsed['error']
           end

data/lib/laziness/api/channels.rb

@@ -1,9 +1,15 @@
 module Slack
   module API
     class Channels < Base
-      def all(exclude_archived=false)
-        response = request :get, 'channels.list', exclude_archived: exclude_archived ? 1 : 0
-        Slack::Channel.parse response, 'channels'
+      def all(exclude_archived=false, page: nil)
+        responses = with_paging(page) do |pager|
+          request :get,
+                  'channels.list',
+                  exclude_archived: exclude_archived ? 1 : 0,
+                  **pager.to_h
+        end
+
+        Slack::Channel.parse_all responses, 'channels'
       end
 
       def archive(id)

data/lib/laziness/api/conversations.rb

@@ -1,13 +1,16 @@
 module Slack
   module API
     class Conversations < Base
-      def all(exclude_archived=false, types='public_channel')
-        response = request :get,
-          'conversations.list',
-          exclude_archived: exclude_archived ? 1 : 0,
-          types: types
+      def all(exclude_archived=false, types='public_channel', page: nil)
+        responses = with_paging(page) do |pager|
+          request :get,
+            'conversations.list',
+            exclude_archived: exclude_archived ? 1 : 0,
+            types: types,
+            **pager.to_h
+        end
 
-        Slack::Conversation.parse response, 'channels'
+        Slack::Conversation.parse_all responses, 'channels'
       end
 
       def archive(id)
@@ -58,12 +61,17 @@ module Slack
         with_nil_response { request :post, 'conversations.leave', channel: id }
       end
 
-      def members(id)
-        response = request :get,
-          'conversations.members',
-          channel: id
+      def members(id, page: nil)
+        responses = with_paging(page) do |pager|
+          request :get,
+                  'conversations.members',
+                  channel: id,
+                  **pager.to_h
+        end
 
-        JSON.parse(response.body)["members"]
+        responses.map do |response|
+          JSON.parse(response.body)["members"]
+        end.flatten
       end
 
       def open(users=[], id=nil, return_im: false)

data/lib/laziness/api/groups.rb

@@ -1,9 +1,15 @@
 module Slack
   module API
     class Groups < Base
-      def all(exclude_archived=false)
-        response = request :get, 'groups.list', exclude_archived: exclude_archived ? 1 : 0
-        Slack::Group.parse response, 'groups'
+      def all(exclude_archived=false, page: nil)
+        responses = with_paging(page) do |pager|
+          request :get,
+                  'groups.list',
+                  exclude_archived: exclude_archived ? 1 : 0,
+                  **pager.to_h
+        end
+
+        Slack::Group.parse_all responses, 'groups'
       end
 
       def archive(id)

data/lib/laziness/api/im.rb

@@ -1,9 +1,12 @@
 module Slack
   module API
     class IM < Base
-      def all
-        response = request :get, 'im.list'
-        Slack::Channel.parse response, 'ims'
+      def all(page: nil)
+        responses = with_paging(page) do |pager|
+          request :get, 'im.list', **pager.to_h
+        end
+
+        Slack::Channel.parse_all responses, 'ims'
       end
 
       def close(channel)

data/lib/laziness/api/users.rb

@@ -1,9 +1,12 @@
 module Slack
   module API
     class Users < Base
-      def all
-        response = request :get, 'users.list'
-        Slack::User.parse response, 'members'
+      def all(page: nil)
+        responses = with_paging(page) do |pager|
+          request :get, 'users.list', **pager.to_h
+        end
+
+        Slack::User.parse_all responses, 'members'
       end
 
       def find(id)

data/lib/laziness/base.rb

@@ -3,8 +3,8 @@ require 'hashie'
 module Slack
   class Base < Hashie::Mash
     class << self
-      def parse(request, key=nil)
-        parsed = JSON.parse(request.body)
+      def parse(response, key=nil)
+        parsed = JSON.parse(response.body)
         parsed = parsed[key] if key && parsed[key]
         if parsed.is_a? Array
           models = []
@@ -14,6 +14,12 @@ module Slack
           new parsed
         end
       end
+
+      def parse_all(responses, key=nil)
+        responses.map do |response|
+          parse(response, key)
+        end.flatten
+      end
     end
   end
 end

data/lib/laziness/cursor.rb

@@ -0,0 +1,60 @@
+module Slack
+  class Cursor
+    attr_reader :page
+
+    def initialize(page)
+      @page = page
+      @max_retries = (page && page[:max_retries]) || 0
+      @sleep_interval = (page && page[:sleep_interval])
+    end
+
+    def paginate(&blk)
+      responses = []
+
+      if block_given?
+        pager = Pager.new(page)
+        retries = 0
+
+        loop do
+          begin
+            response = blk.call(pager)
+          rescue Slack::TooManyRequestsError => e
+            raise e if retries >= max_retries
+
+            retries += 1
+
+            sleep(e.retry_after_in_seconds)
+            next
+          end
+
+          responses << response
+
+          break unless has_cursor?(response)
+
+          retries = 0
+
+          pager = pager.next(next_cursor(response))
+
+          sleep(sleep_interval) if sleep_interval
+        end
+      end
+
+      responses
+    end
+
+    private
+
+    attr_reader :max_retries, :sleep_interval
+
+    def next_cursor(response)
+      response["response_metadata"]["next_cursor"] unless !has_cursor?(response)
+    end
+
+    def has_cursor?(response)
+      response.respond_to?(:[]) &&
+        !response["response_metadata"].nil? &&
+          !response["response_metadata"]["next_cursor"].nil? &&
+          !response["response_metadata"]["next_cursor"].empty?
+    end
+  end
+end

data/lib/laziness/errors.rb

@@ -94,4 +94,23 @@ module Slack
       super "You cannot archive the last channel for a restricted account."
     end
   end
+
+  class TooManyRequestsError < APIError
+    def initialize(response)
+      @response = response
+    end
+
+    def message
+      "Retry after #{retry_after_in_seconds} seconds"
+    end
+
+    def retry_after_in_seconds
+      retry_after = response.headers["retry-after"]
+      (retry_after || 0).to_i
+    end
+
+    private
+
+    attr_reader :response
+  end
 end

data/lib/laziness/pager.rb

@@ -0,0 +1,32 @@
+require "ostruct"
+
+module Slack
+  class Pager
+    attr_reader :cursor, :limit, :page
+
+    def initialize(page)
+      @page = page.dup
+      @limit = @page[:limit] unless empty?
+    end
+
+    def empty?
+      page.nil? || page.empty?
+    end
+
+    def to_h
+      { cursor: cursor, limit: limit }
+    end
+
+    def next(cursor)
+      self.class.new(page).tap do |pager|
+        pager.cursor = cursor
+      end
+    end
+
+    protected
+
+    def cursor=(cursor)
+      @cursor = cursor
+    end
+  end
+end

data/lib/laziness/version.rb

@@ -1,3 +1,3 @@
 module Laziness
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/lib/laziness.rb

@@ -6,11 +6,13 @@ require 'laziness/channel'
 require 'laziness/chat'
 require 'laziness/client'
 require 'laziness/conversation'
+require 'laziness/cursor'
 require 'laziness/errors'
 require 'laziness/group'
 require 'laziness/message'
 require 'laziness/oauth'
 require 'laziness/observer'
+require 'laziness/pager'
 require 'laziness/real_time_client'
 require 'laziness/registry'
 require 'laziness/session'

data/spec/laziness/api/conversations_spec.rb

@@ -13,6 +13,20 @@ describe Slack::API::Conversations do
       expect(conversations.length).to eq 1
       expect(conversations[0].id).to eq "C02BLAH"
     end
+
+    context 'with paging' do
+      it 'pages through until there are no more pages left' do
+        stub_slack_request :get,
+          "conversations.list?token=#{access_token}&exclude_archived=0&"\
+          "limit=1000&"\
+          "types=public_channel",
+          "conversations_list.json"
+
+        conversations = subject.all(page: { limit: 1000 })
+        expect(conversations.length).to eq 1
+        expect(conversations[0].id).to eq "C02BLAH"
+      end
+    end
   end
 
   describe '.archive' do

data/spec/laziness/base_spec.rb

@@ -0,0 +1,20 @@
+describe Slack::Base do
+  describe "#parse_all" do
+    let(:responses) do
+      [
+        double(:response,
+               body: '{ "ok": true, "messages": [{ "id": "1234", "type": "blah" }] }'),
+        double(:response,
+               body: '{ "ok": true, "messages": [{ "id": "4567", "type": "bleh" }] }')
+      ]
+    end
+
+    it "parses all of the messages in an array" do
+      result = described_class.parse_all responses, 'messages'
+
+      expect(result.count).to eq 2
+      expect(result.first.id).to eq "1234"
+      expect(result.last.id).to eq "4567"
+    end
+  end
+end

data/spec/laziness/cursor_spec.rb

@@ -0,0 +1,129 @@
+describe Slack::Cursor do
+  describe '#initialize' do
+    let(:page) { { limit: 10 } }
+
+    it 'initializes with page attributes' do
+      expect(described_class.new(page).page).to eq page
+    end
+  end
+
+  describe '#paginate' do
+    let(:first_response) do
+      {
+        "ok" => true,
+        "channels" => [{
+          "id" => "C01"
+        }],
+        "response_metadata" => {
+          "next_cursor" => "onto-second-request"
+        }
+      }
+    end
+    let(:last_response) do
+      {
+        "ok" => true,
+        "channels" => [{
+          "id" => "C03"
+        }],
+        "response_metadata" => {
+          "next_cursor" => ""
+        }
+      }
+    end
+    let(:page) { { limit: 10 } }
+    let(:second_response) do
+      {
+        "ok" => true,
+        "channels" => [{
+          "id" => "C02"
+        }],
+        "response_metadata" => {
+          "next_cursor" => "onto-last-request"
+        }
+      }
+    end
+
+    subject { described_class.new(page) }
+
+    it 'does not require a block' do
+      expect { subject.paginate }.to_not raise_error
+    end
+
+    it 'yields a pager' do
+      expect { |b| subject.paginate(&b) }.to yield_with_args(Slack::Pager)
+    end
+
+    it 'returns the results of each yield' do
+      expected = [first_response, second_response, last_response]
+      index = 0
+      responses = subject.paginate do |pager|
+        response = expected[index]
+        index += 1
+        response
+      end
+
+      expect(responses).to eq(expected)
+    end
+
+    it 'updates the cursor on the pager' do
+      expect_any_instance_of(Slack::Pager).to \
+        receive(:next).with("onto-last-request").and_call_original
+
+      responses = [second_response, last_response]
+      subject.paginate do |pager|
+        responses.shift
+      end
+    end
+
+    context 'with a too many requests error' do
+      let(:page) { { limit: 10, max_retries: 2 } }
+      let(:response) { OpenStruct.new(headers: { 'retry-after' => '0' }) }
+
+      it 'tries again when there is a max retries setting' do
+        number_of_tries = 0
+
+        expect {
+          subject.paginate do |pager|
+            number_of_tries += 1
+            raise Slack::TooManyRequestsError, response
+          end
+        }.to raise_error(Slack::TooManyRequestsError)
+
+        expect(number_of_tries).to eq 3
+      end
+
+      context 'without a max retries' do
+        it 'bubbles up the error' do
+          expect do
+            subject.paginate do |pager|
+              raise Slack::TooManyRequestsError, response
+            end
+          end.to raise_error Slack::TooManyRequestsError
+        end
+      end
+    end
+
+    context 'with a sleep interval' do
+      let(:page) { { limit: 10, sleep_interval: 2 } }
+
+      it 'sleeps in between requests' do
+        expect(subject).to receive(:sleep).with(2)
+
+        responses = [second_response, last_response]
+        subject.paginate do |pager|
+          responses.shift
+        end
+      end
+    end
+
+    context 'with a nil page' do
+      subject { described_class.new(nil) }
+
+      it 'yields with an empty pager' do
+        subject.paginate do |pager|
+          expect(pager).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/laziness/errors_spec.rb

@@ -154,6 +154,19 @@ describe 'API errors' do
     expect { subject.channels.all }.to raise_error Slack::NoChannelError
   end
 
+  it 'raises a too many requests error if the status is 429' do
+    response = {
+      ok: false,
+      error: "ratelimited"
+    }
+    stub_request(:get, "https://slack.com/api/users.list?token=#{access_token}").
+        to_return(status: 429,
+                  body: response.to_json,
+                  headers: { "Retry-After" => "30" })
+    expect { subject.users.all }.to \
+      raise_error Slack::TooManyRequestsError, "Retry after 30 seconds"
+  end
+
   it 'raises an http error if the error is not known' do
     response = {
       ok: false,

data/spec/laziness/message_spec.rb

@@ -1,7 +1,8 @@
 describe Slack::Message do
   describe "#parse" do
     it "initializes a new message with a JSON string" do
-      message = Slack::Message.parse '{ "id": "1234", "type": "blah" }'
+      message = described_class.parse '{ "id": "1234", "type": "blah" }'
+
       expect(message).to be_a Slack::Message
       expect(message.id).to eq "1234"
       expect(message.type).to eq :blah
@@ -10,15 +11,18 @@ describe Slack::Message do
 
   describe "#generate" do
     it "generates a new message with a random id and type" do
-      message = Slack::Message.generate text: "This is a test"
+      message = described_class.generate text: "This is a test"
+
       expect(message.id).to_not be_empty
       expect(message.type).to eq :message
       expect(message.text).to eq "This is a test"
     end
 
     it "can have an id specified" do
-      expect(Slack::Message).to_not receive(:generate_id)
-      message = Slack::Message.generate id: 12345
+      expect(described_class).to_not receive(:generate_id)
+
+      message = described_class.generate id: 12345
+
       expect(message.id).to eq 12345
     end
   end

data/spec/laziness/pager_spec.rb

@@ -0,0 +1,60 @@
+describe Slack::Pager do
+  describe "#initialize" do
+    let(:page) { { limit: 20 } }
+
+    it "initializes with a page" do
+      expect(described_class.new(page).page).to eq page
+    end
+
+    it "saves the limit" do
+      expect(described_class.new(page).limit).to eq 20
+    end
+
+    it "initializes a nil cursor" do
+      expect(described_class.new(page).cursor).to be_nil
+    end
+  end
+
+  describe "#empty?" do
+    context "with a non-empty page" do
+      it "is not empty" do
+        expect(described_class.new({ limit: 200 })).to_not be_empty
+      end
+    end
+
+    context "with an empty page" do
+      it "is empty" do
+        expect(described_class.new({})).to be_empty
+      end
+    end
+
+    context "with a nil page" do
+      it "is empty" do
+        expect(described_class.new(nil)).to be_empty
+      end
+    end
+  end
+
+  describe "#to_h" do
+    subject { described_class.new({ limit: 200 }) }
+
+    it "returns a hash with the limit and the cursor" do
+      expect(subject.to_h).to eq({ limit: 200, cursor: nil })
+    end
+  end
+
+  describe "#next" do
+    subject { described_class.new({ limit: 200 }) }
+
+    it "returns a new instance of the pager" do
+      pager = subject.next("next")
+
+      expect(pager).to be_instance_of(described_class)
+      expect(pager).to_not equal subject
+    end
+
+    it "sets the cursor" do
+      expect(subject.next("next").cursor).to eq "next"
+    end
+  end
+end

data/spec/support/fixtures/conversations_list.json

@@ -26,5 +26,8 @@
       },
       "num_members": 2
     }
-  ]
+  ],
+  "response_metadata": {
+    "next_cursor": "next"
+  }
 }

data/spec/support/slack_stub_factory.rb

@@ -1,7 +1,16 @@
 module SlackStubFactory
-  def stub_slack_request(method, path, fixture)
+  def stub_slack_request(method, path, fixtures)
+    fixtures = [fixtures].flatten
+
     full_path = "https://slack.com/api/#{path}"
-    stub_request(method, full_path).to_return(status: 200, body: slack_json_fixture(fixture))
+
+    stub = stub_request(method, full_path)
+    begin
+      fixture = fixtures.shift
+      stub.to_return(status: 200, body: slack_json_fixture(fixture))
+    end while !fixtures.empty?
+
+    stub
   end
 
   def slack_json_fixture(fixture)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: laziness
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Jamie Wright
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-11 00:00:00.000000000 Z
+date: 2019-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -100,11 +100,13 @@ files:
 - lib/laziness/chat.rb
 - lib/laziness/client.rb
 - lib/laziness/conversation.rb
+- lib/laziness/cursor.rb
 - lib/laziness/errors.rb
 - lib/laziness/group.rb
 - lib/laziness/message.rb
 - lib/laziness/oauth.rb
 - lib/laziness/observer.rb
+- lib/laziness/pager.rb
 - lib/laziness/real_time_client.rb
 - lib/laziness/registry.rb
 - lib/laziness/session.rb
@@ -119,10 +121,13 @@ files:
 - spec/laziness/api/oauth_spec.rb
 - spec/laziness/api/rtm_spec.rb
 - spec/laziness/api/users_spec.rb
+- spec/laziness/base_spec.rb
 - spec/laziness/client_spec.rb
+- spec/laziness/cursor_spec.rb
 - spec/laziness/errors_spec.rb
 - spec/laziness/message_spec.rb
 - spec/laziness/observer_spec.rb
+- spec/laziness/pager_spec.rb
 - spec/laziness/real_time_client_spec.rb
 - spec/laziness/registry_spec.rb
 - spec/spec_helper.rb
@@ -181,10 +186,13 @@ test_files:
 - spec/laziness/api/oauth_spec.rb
 - spec/laziness/api/rtm_spec.rb
 - spec/laziness/api/users_spec.rb
+- spec/laziness/base_spec.rb
 - spec/laziness/client_spec.rb
+- spec/laziness/cursor_spec.rb
 - spec/laziness/errors_spec.rb
 - spec/laziness/message_spec.rb
 - spec/laziness/observer_spec.rb
+- spec/laziness/pager_spec.rb
 - spec/laziness/real_time_client_spec.rb
 - spec/laziness/registry_spec.rb
 - spec/spec_helper.rb