talkbird 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 978edc8d5c34ca0fe0fd8ff76d1777784d374ac57c06042c9fdafc57696acdfd
+  data.tar.gz: c9689d6c654bbe36cc8b9c58185dbaf72657853c0bbbbdb51efab40677eac5d6
+SHA512:
+  metadata.gz: 84a9813b6be54f37fe91f8286d76682ae88371b0ca6ab583a975c4eb9a33d8f94fba91769abc4a4a4875475879fa467a9b297c89120e8048c40a38942caff949
+  data.tar.gz: f93e25ae58c4616c8f6ba5a47683f72e85ac9d4cb5ccff389589ceac5f7ef4929d3b80ed7e6a9eb4ea5ec69cee8844f0ec8f880f5200c5cdba22423f6eee639c

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.env
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/Gemfile.lock
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.reek.yml

@@ -0,0 +1,20 @@
+---
+
+# Generic smell configuration
+detectors:
+  # According to a study done by Card, Church, and Agresti (1986) and a study
+  # done by Card and Glass (1990) small routines with 32 or fewer lines of code
+  # were not corelated with lower cost or fault rate.
+  #
+  # Evidence suggested that larger routines (65 lines of code or more) were
+  # cheaper to develop per line of code.
+  # -- Code Complete 2
+  #
+  # Since Ruby is more terse than a lot of languages and because there seems to
+  # be a relationship between error rate and structural complexity, the limit
+  # should probably be slightly lower. However, the default value of 5 is too
+  # low.
+  TooManyStatements:
+    max_statements: 20
+  TooManyMethods:
+    max_methods: 30

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,49 @@
+AllCops:
+  TargetRubyVersion: 2.4.2
+
+MethodLength:
+  Max: 20
+
+BlockLength:
+  Max: 70
+
+  Exclude:
+    - 'Rakefile'
+    - 'rakelib/**/*.rake'
+    - 'spec/**/*.rb'
+
+Metrics/LineLength:
+  Max: 80
+
+Naming/RescuedExceptionsVariableName:
+  PreferredName: exception
+
+Style/GuardClause:
+  Enabled: false
+
+Style/Next:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: false
+
+Style/SymbolProc:
+  Enabled: false
+
+Style/WordArray:
+  Enabled: false
+
+Style/YodaCondition:
+  EnforcedStyle: forbid_for_equality_operators_only
+
+Layout/EmptyLinesAroundClassBody:
+  EnforcedStyle: empty_lines_except_namespace
+
+Layout/EmptyLinesAroundModuleBody:
+  EnforcedStyle: empty_lines_except_namespace
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: aligned
+
+Layout/SpaceInsidePercentLiteralDelimiters:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.2
+before_install: gem install bundler -v 1.17.3

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in talkbird.gemspec
+gemspec

data/README.md

@@ -0,0 +1,7 @@
+# Talkbird
+
+Unofficial SendBird API gem.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/andreimaxim/talkbird.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'talkbird'
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/talkbird.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'addressable'
+require 'http'
+require 'multi_json'
+require 'active_support/notifications'
+
+require 'talkbird/version'
+require 'talkbird/client'
+
+require 'talkbird/result'
+require 'talkbird/result/basic'
+require 'talkbird/result/success'
+require 'talkbird/result/paginated_success'
+require 'talkbird/result/failure'
+require 'talkbird/result/exception'
+
+require 'talkbird/instrumentation/event'
+
+require 'talkbird/entity/channel'
+require 'talkbird/entity/message'
+require 'talkbird/entity/user'
+
+# Unofficial SendBird API client.
+module Talkbird
+end

data/lib/talkbird/client.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Talkbird
+  # Class that handles the basic calls to SendBird
+  class Client
+
+    VERSION = 'v3'
+    SCHEME = 'https'
+
+    include Singleton
+
+    class << self
+
+      def token
+        token = ENV['SENDBIRD_API_TOKEN'].to_s
+
+        if token.empty?
+          raise ArgumentError, 'Missing SendBird API token from ENV'
+        else
+          token
+        end
+      end
+
+      def application_id
+        app_id = ENV['SENDBIRD_APP_ID'].to_s
+
+        if app_id.empty?
+          raise ArgumentError, 'Missing SendBird application ID from ENV'
+        else
+          app_id
+        end
+      end
+
+      def host
+        "api-#{application_id}.sendbird.com"
+      end
+
+      def uri(path, params = {})
+        if path.is_a?(HTTP::URI)
+          build_uri_from_existing(path, params)
+        else
+          build_uri_from_partial_path(path, params)
+        end
+      end
+
+      def request(method, path, opts = {})
+        default_headers = {
+          'Api-Token' => token,
+          'Content-Type' => 'application/json; charset=utf8'
+        }
+
+        req = HTTP::Request.new(
+          verb: method,
+          uri: uri(path, opts[:params]),
+          headers: (opts[:headers] || {}).merge(default_headers),
+          body: MultiJson.dump(opts[:body])
+        )
+
+        response = Client.instance.request(req, opts)
+        Talkbird::Result.create(response)
+      end
+
+      private
+
+      def build_uri_from_existing(path, params = {})
+        uri = Addressable::URI.parse(path)
+        extra_params = (params || {})
+                         .transform_keys { |key| key.to_s.downcase }
+        opts = {
+          scheme: uri.scheme,
+          host: uri.host,
+          path: uri.path
+        }
+
+        # Remove the token from the existing query as it is most likely invalid
+        # anyway.
+        query = (uri.query_values || {}).reject { |name, _val| name == 'token' }
+
+        opts[:query_values] = if query.empty? && extra_params.empty?
+                                nil
+                              else
+                                query.merge(extra_params)
+                              end
+
+        Addressable::URI.new(opts)
+      end
+
+      def build_uri_from_partial_path(partial_path, params = {})
+        path = [Client::VERSION, partial_path].join('/')
+        opts = {
+          scheme: Client::SCHEME,
+          host: Client.host,
+          path: path
+        }
+
+        # Adding the `query_values` when the `params` is an empty hash
+        # will add a `?` at the end of the URL.
+        opts[:query_values] = params if params && !params.empty?
+
+        Addressable::URI.new(opts)
+      end
+
+    end
+
+    def initialize
+      @http = HTTP.use(
+        instrumentation: {
+          instrumenter: ActiveSupport::Notifications.instrumenter,
+          namespace: Talkbird::Instrumentation::Event::NAMESPACE
+        }
+      )
+
+      Instrumentation::Event.register_instrumentation_for_request
+      Instrumentation::Event.register_instrumentation_for_response
+    end
+
+    def request(req, opts = {})
+      options = HTTP::Options.new(opts)
+      @http.perform(req, options)
+    end
+
+  end
+end

data/lib/talkbird/entity/channel.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Talkbird
+  module Entity
+    # SendBird channel
+    class Channel
+
+      DEFAULTS = {
+        distinct: true,
+        is_ephemeral: true
+      }.freeze
+
+      class << self
+
+        def find(from, to)
+          result = Client.request(
+            :get,
+            "users/#{from}/my_group_channels",
+            params: {
+              members_exactly_in: to,
+              order: 'latest_last_message',
+              distinct_mode: 'distinct',
+              public_mode: 'private',
+              show_member: true,
+              limit: 1
+            }
+          )
+
+          if result.is_a?(Result::Success)
+            Channel.new(result.body[:channels].first)
+          else
+            false
+          end
+        end
+
+        def create(from, to, opts = {})
+          body = DEFAULTS.merge(opts)
+
+          body[:channel_url] = opts.fetch(:id) { SecureRandom.uuid }
+          body[:user_ids] = [from, to]
+
+          result = Client.request(
+            :post,
+            'group_channels',
+            body: body
+          )
+
+          if result.is_a?(Result::Success)
+            Channel.new(result.body)
+          else
+            false
+          end
+        end
+
+        def find_or_create(from, to)
+          Channel.find(from, to) || Channel.create(from, to)
+        end
+
+      end
+
+      def initialize(data = {})
+        @data = data
+      end
+
+      def id
+        @data[:channel_url]
+      end
+
+      def update(message)
+        body = {
+          user_id: message.sender.id,
+          message: message.body,
+          message_type: 'MESG',
+        }
+
+        result = Client.request(
+          :post,
+          "group_channels/#{id}/messages",
+          body: body
+        )
+
+        if result.is_a?(Result::Success)
+          Entity::Message.build(result.body)
+        else
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/talkbird/entity/message.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Talkbird
+  module Entity
+    # SendBird message
+    class Message
+
+      attr_reader :sender
+      attr_reader :receiver
+      attr_reader :body
+
+      class << self
+
+        def build(response)
+          response
+        end
+
+      end
+
+      def initialize(from, to, body)
+        @sender = User.find_or_create(from)
+        @receiver = User.find_or_create(to)
+        @body = body
+      end
+
+      def deliver
+        return false if !sender || !receiver
+
+        channel = Entity::Channel.find_or_create(sender.id, receiver.id)
+        puts channel.inspect
+        channel.update(self)
+      end
+
+    end
+  end
+end

data/lib/talkbird/entity/user.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Talkbird
+  module Entity
+    # A SendBird User entity.
+    #
+    # Users can chat with each other by participanting in open channels and
+    # joining group channels. They are identified by their own unique ID,
+    # and may have a customized nickname and profile image.
+    #
+    # Various attributes of each user, as well as their actions can be
+    # managed through the API.
+    class User
+
+      DEFAULTS = {
+        nickname: '',
+        profile_url: '',
+        issue_session_token: true
+      }.freeze
+
+      class << self
+
+        # Find a user with a specific ID.
+        #
+        # @param id [String] The user's unique ID
+        # @return [User, Boolean]
+        def find(id)
+          result = Client.request(:get, "users/#{id}")
+
+          if result.is_a?(Result::Success)
+            User.new(result.body)
+          else
+            false
+          end
+        end
+
+        def create(id, opts = {})
+          body = DEFAULTS.merge(opts)
+          result = Client.request(:post, 'users', body: body)
+
+          if result.is_a?(Result::Success)
+            User.new(result.body)
+          else
+            false
+          end
+        end
+
+        def find_or_create(id, opts = {})
+          if id.is_a?(Entity::User)
+            id
+          else
+            User.find(id) || User.create(id, opts)
+          end
+        end
+
+        # Find all the users in the application.
+        #
+        # WARNING: This may take a lot of time.
+        def all
+          result = Client.request(:get, 'users')
+
+          if result.is_a?(Result::Success)
+            result.body[:users].map { |data| User.new(data) }
+          else
+            []
+          end
+        end
+
+      end
+
+      def initialize(data = {})
+        @data = data
+      end
+
+      ## Basic user properties
+      #
+      # The unique ID of the user
+      def id
+        @data[:user_id]
+      end
+
+      # The user's nickname.
+      def nickname
+        @data[:nickname]
+      end
+
+      # The URL of the user's profile image.
+      def profile_url
+        @data[:profile_url]
+      end
+
+      # An opaque string that identifies the user.
+      #
+      # It is recommended that every user has their own access token and
+      # provides it uopn login for security.
+      def access_token
+        @data[:access_token]
+      end
+
+      # An array of inforation of session tokens that identifies the user
+      # session and which have no validity after their own expiration time.
+      #
+      # Each of items consists of two `session_token` and `expires_at`
+      # properties. The `session_token` is an opaque string and `expires_at`
+      # is a validation period of the session token.
+      #
+      # It is recommended that a new session token is periodically isseud to
+      # every user, and provided upon the user's login for security.
+      def session_tokens
+        @data[:session_tokens]
+      end
+
+      # Indicates if the user has ever logged into the application so far.
+      def ever_logged_in?
+        @data[:has_ever_logged_in]
+      end
+
+      # Indicates whether the user is currently active within the application.
+      def active?
+        @data[:active]
+      end
+
+      # Indicates whether the user is currently connected to a SendBird server.
+      def online?
+        @data[:online]
+      end
+
+      # An array of unique identifies of the user which are used as discovering
+      # keys when searching and adding friends.
+      def discovery_keys
+        @data[:discovery_keys]
+      end
+
+      # The time recoreded when the user goes offline, to indicate when they
+      # were last seen online, in Unix miliseconds format.
+      #
+      # If the user is online, the value is set to 0.
+      def last_seen_at
+        @data[:last_seen_at]
+      end
+
+      # An array of key-value pair items which store additional user
+      # information.
+      def metadata
+        @data[:metadata]
+      end
+
+      # Send a message to a user
+      #
+      # @param to [String] The Sendbird user ID that should receive the message
+      # @param text [String] The message body
+      #
+      # @return [Boolean]
+      def message(to, text)
+        Entity::Message.new(self, to, text).deliver
+      end
+
+      def to_h
+        @data.to_h
+      end
+
+      def to_s
+        "#<Talkbird::Entity::User:#{id} active=#{active?} online=#{online?}>"
+      end
+
+    end
+  end
+end

data/lib/talkbird/instrumentation/event.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Talkbird
+  module Instrumentation
+    # General instrumentation event for an ActiveSupport
+    # notification.
+    class Event
+
+      NAMESPACE = 'sendbird'
+      START_EVENT = 'start_request.sendbird'
+      END_EVENT = 'request.sendbird'
+
+      class << self
+
+        def register_instrumentation_for_request
+          ActiveSupport::Notifications.subscribe(START_EVENT) do |*params|
+            data = Talkbird::Instrumentation::Event.new(params)
+            $stdout.puts data
+          end
+        end
+
+        def register_instrumentation_for_response
+          ActiveSupport::Notifications.subscribe(END_EVENT) do |*params|
+            data = Talkbird::Instrumentation::Event.new(params)
+            $stdout.puts data
+          end
+        end
+
+        def debug?
+          ENV.key?('SENDBIRD_DEBUG')
+        end
+
+        def normalized_request_data(payload)
+          data = payload[:request]
+
+          hsh = {
+            type: 'request',
+            method: data.verb.upcase,
+            url: anonymize_app_id_from_url(data.uri)
+          }
+
+          hsh[:body] = data.body if Event.debug?
+          hsh
+        end
+
+        def normalized_response_data(payload)
+          data = payload[:response]
+
+          hsh = {
+            type: 'response',
+            code: data.status,
+            url: anonymize_app_id_from_url(data.uri)
+          }
+
+          hsh[:body] = data.body if Event.debug?
+          hsh
+        end
+
+        def anonymize_app_id_from_url(url)
+          app_id = Talkbird::Client.application_id.downcase
+
+          url.to_s.gsub(app_id, '...')
+        end
+
+      end
+
+      # Array of expected params:
+      # * name
+      # * start_time
+      # * finish_time
+      # * id of the event
+      # * payload (simple hash with either :request or :response)
+      def initialize(params)
+        @name = params[0]
+        @start_time = params[1]
+        @finish_time = params[2]
+        @id = params[3]
+        @payload = params[4]
+      end
+
+      def normalized_payload
+        if @name == START_EVENT
+          Event.normalized_request_data(@payload)
+        elsif @name == END_EVENT
+          Event.normalized_response_data(@payload)
+        else
+          {}
+        end
+      end
+
+      def to_h
+        data = normalized_payload
+
+        {
+          id: @id
+        }.merge(data)
+      end
+
+      def to_s
+        to_h.map { |name, val| "#{name}=#{val}" }.join(' ')
+      end
+
+    end
+  end
+end

data/lib/talkbird/result.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Talkbird
+  # Encapsulation of the SendBird API responses.
+  module Result
+
+    # Select the right result type based on the response.
+    def self.create(response)
+      status_code = response.code
+
+      if 200 <= status_code && status_code < 400
+        PaginatedSuccess.new(response).reduce
+      else
+        Result::Failure.new(response)
+      end
+    rescue StandardError => exception
+      Result::Exception.new(response, exception)
+    end
+
+  end
+end

data/lib/talkbird/result/basic.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Talkbird
+  module Result
+    # Core class for Result-like monads.
+    class Basic
+
+    end
+  end
+end

data/lib/talkbird/result/exception.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Talkbird
+  module Result
+    # Class representing a result as an exception.
+    class Exception < Basic
+
+      def initialize(exception, result)
+        @exception = exception
+        @result = result
+      end
+
+    end
+  end
+end

data/lib/talkbird/result/failure.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Talkbird
+  module Result
+    class Failure < Basic
+
+      attr_reader :result
+
+      def initialize(result)
+        @result = result
+        @body = MultiJson.load(result.body.to_s, symbolize_keys: true)
+      end
+
+      def code
+        @body[:code]
+      end
+
+      def message
+        @body[:message]
+      end
+
+    end
+  end
+end

data/lib/talkbird/result/paginated_success.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Talkbird
+  module Result
+    # A variation of the result which should support composition.
+    class PaginatedSuccess
+
+      class << self
+
+        def deep_merge(data, elem)
+          data.merge(elem) do |key, oldval, newval|
+            if key == :next
+              nil
+            else
+              oldval + newval
+            end
+          end
+        end
+
+      end
+
+      def initialize(result)
+        @result = result
+      end
+
+      def reduce
+        body = compose.reduce({}) { |data, el| PaginatedSuccess.deep_merge(data, el.body) }
+        response = HTTP::Response.new(
+          status: @result.status,
+          version: @result.version,
+          body: MultiJson.dump(body),
+          headers: @result.headers
+        )
+
+        Result::Success.new(response, body)
+      end
+
+      def compose
+        body = MultiJson.load(@result.body.to_s, symbolize_keys: true)
+        token = body[:next].to_s
+
+        if !token.empty?
+          [
+            Result::Success.new(@result, body),
+            next_page(token)
+          ].flatten
+        else
+          [Result::Success.new(@result, body)]
+        end
+      end
+
+      def next_page(token)
+        Talkbird::Client.request(
+          :get,
+          @result.uri,
+          params: { token: token, limit: 100 }
+        )
+      end
+
+    end
+  end
+end

data/lib/talkbird/result/success.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Talkbird
+  module Result
+    # Success monad (sort of).
+    class Success
+
+      attr_reader :body
+
+      def initialize(result, body = nil)
+        @result = result
+        @body = parse_body(body)
+      end
+
+      def status_code
+        @result.code
+      end
+
+      def parse_body(body)
+        if body.nil?
+          MultiJson.load(@result.body.to_s)
+        elsif body.is_a?(String)
+          MultiJson.load(body)
+        else
+          body
+        end
+      end
+
+    end
+  end
+end

data/lib/talkbird/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Talkbird
+
+  VERSION = '0.0.2'
+
+end

data/talkbird.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'talkbird/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'talkbird'
+  spec.version       = Talkbird::VERSION
+  spec.authors       = 'Andrei Maxim'
+  spec.email         = 'andrei@andreimaxim.ro'
+
+  spec.summary       = 'Unofficial gem for the SendBird API'
+  spec.homepage      = 'https://github.com/andreimaxim/talkbird'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added
+  # into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`
+      .split("\x0")
+      .reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '>= 5.0'
+  spec.add_dependency 'multi_json', '~> 1.14'
+  spec.add_dependency 'http', '~> 4.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'pry', '~> 0.12.2'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: talkbird
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Andrei Maxim
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email: andrei@andreimaxim.ro
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".reek.yml"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/talkbird.rb
+- lib/talkbird/client.rb
+- lib/talkbird/entity/channel.rb
+- lib/talkbird/entity/message.rb
+- lib/talkbird/entity/user.rb
+- lib/talkbird/instrumentation/event.rb
+- lib/talkbird/result.rb
+- lib/talkbird/result/basic.rb
+- lib/talkbird/result/exception.rb
+- lib/talkbird/result/failure.rb
+- lib/talkbird/result/paginated_success.rb
+- lib/talkbird/result/success.rb
+- lib/talkbird/version.rb
+- talkbird.gemspec
+homepage: https://github.com/andreimaxim/talkbird
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Unofficial gem for the SendBird API
+test_files: []