streamelements 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f59098ef3eac1b544e2ddb657c0c3c5abd92df95ca5a7b0c6b1a6263055b0688
-  data.tar.gz: 45073cf8652ed336f7c872dcbc80e153d6d3e64416b19307cb8643c328b961bb
+  metadata.gz: 83d2ea9888a42229e5016f02f1dc44bc4bbb6dcd8e2518f18f205665af4085d5
+  data.tar.gz: 693b8d5938293d15a82eada641f6f1f4de021eaad7a68457d9bc2e179d7bd3db
 SHA512:
-  metadata.gz: 753fd8a5d596772a72b9e80283b1ff79088db9f6f08d84423e9e3ca524d0d2c8077a0d781e3744fe9d54f40ec35616a5314428c2cae685f66a37bdf71afbef2b
-  data.tar.gz: 8d3dc3c12760aed80003adcc619ff1a207ecfeab5e01529ca697cbcb2ca78782028f4d25341475515ce4d484cf07cb5cc5130f74e93904c13ef9af23ba4d2b8d
+  metadata.gz: f76b12a8c58996a31cfdc3849e237c6d4b1c4ded028cfe7bcba7a60379aa2e864d5dfd7191cb8677fbf06594c0a3284cfa0a5039a903579e717378d328ef04dc
+  data.tar.gz: b71d769c436f467bf3405df589f2ac8d8eb2fa44e06b1e3a040b69a2ab7e2582d3203e7f21730bae46b2deac81d43f863e05316851765a37339eb99d21f7ab83

data/README.md

@@ -12,27 +12,50 @@ gem "streamelements"
 
 ## Usage
 
-### Authentication
+### Set Client Details
 
-Firstly you'll need to set a JWT Token and Channel ID.
+Firstly you'll need to the access token, which can be an oAuth Token or JWT.
 
 ```ruby
-StreamElements.configure do |config|
-  config.token = ENV["STREAMELEMENTS_JWT_TOKEN"]
-  config.channel = ENV["STREAMELEMENTS_CHANNEL_ID"]
-end
+@client = StreamElements::Client.new(access_token: "abc123")
 ```
 
+### Resources
+
+The gem maps as closely as we can to the StreamElements API so you can easily convert API examples to gem code.
+
+Responses are created as objects like `StreamElements::Channel`. Having types like `StreamElements::User` is handy for understanding what
+type of object you're working with. They're built using OpenStruct so you can easily access data in a Ruby-ish way.
+
+### Channels
+
+```ruby
+# Get the current channel
+@client.channels.me
+```
+
+
+### Users
+
+```ruby
+# Get the current user
+@client.users.current
+
+# Get the users Channels
+@client.users.channels
+```
+
+
 ### Activities
 
 ```ruby
 # Retrieve a list of Activities
 # https://dev.streamelements.com/docs/api-docs/861a5d5450bbb-channel
-StreamElements::Activity.list
+@client.activities.list(channel: "channel-id", after:, before:, limit:, types:)
 
 # Retrieve the Top Activities
 # https://dev.streamelements.com/docs/api-docs/2ce44d058b16b-channel-top
-StreamElements::Activity.top
+@client.activities.top(channel: "channel-id", period:, offset:, limit:, type:)
 ```
 
 ### Tips
@@ -40,61 +63,48 @@ StreamElements::Activity.top
 ```ruby
 # Retrieve a list of Tips
 # https://dev.streamelements.com/docs/api-docs/704e5580be2d9-channel
-StreamElements::Tip.list
+@client.tips.list(channel: "channel-id", after: "2024-01-01", sort: "createdAt", limit: 10)
 
 # Retrieve a Tip
-StreamElements::Tip.retrieve(id: "tip-id")
+@client.tips.retrieve(channel: "channel-id", id: "tip-id")
 
 # Retrieve the Tip Tips
 # https://dev.streamelements.com/docs/api-docs/b404f906817c4-channel-top
-StreamElements::Tip.top
+@client.tips.top(channel: "channel-id")
 ```
 
 ### Song Requests
 
 ```ruby
 # Retrieve the current playing song
-StreamElements::SongRequest.playing
+@client.song_requests.playing(channel: "channel-id")
 
 # Retrieve a list of songs in the queue
-StreamElements::SongRequest.queue
-
-# Retrieve a list of previous songs
-StreamElements::SongRequest.queue
+@client.song_requests.queue(channel: "channel-id")
 
 # Add a song to the queue
 # video is the YouTube video ID or URL
-StreamElements::SongRequest.add(video: "video-id")
+@client.song_requests.add(channel: "channel-id", video: "video-id")
 
 # Pause the player
-StreamElements::SongRequest.pause
+@client.song_requests.pause(channel: "channel-id")
 
 # Resume the player
-StreamElements::SongRequest.play
+@client.song_requests.play(channel: "channel-id")
 
 # Set the volume of the player
 # volume is a number between 0 and 100
-StreamElements::SongRequest.volume(volume: 50)
+@client.song_requests.volume(channel: "channel-id", volume: 50)
 
 # Skip the current song
-StreamElements::SongRequest.skip
+@client.song_requests.skip(channel: "channel-id")
 
 # Get the current song request settings
-StreamElements::SongRequest.settings
+@client.song_requests.settings(channel: "channel-id")
 
 # Set the current song request settings
 # settings is a hash of settings
-StreamElements::SongRequest.update_settings(settings: { max_requests: 5 })
-```
-
-### Users
-
-```ruby
-# Get the current user
-StreamElements::User.current
-
-# Get the users Channels
-StreamElements::User.channels
+@client.song_requests.update_settings(channel: "channel-id", settings: { max_requests: 5 })
 ```
 
 ## Contributing

data/lib/stream_elements/client.rb

@@ -1,74 +1,47 @@
 module StreamElements
   class Client
 
-    class << self
+    BASE_URL = "https://api.streamelements.com/kappa/v2"
 
-      def connection
-        @connection ||= Faraday.new("https://api.streamelements.com/kappa/v2") do |conn|
-          conn.request :authorization, :Bearer, StreamElements.config.token
+    attr_reader :access_token
 
-          conn.headers = {
-            "User-Agent" => "streamelements/v#{VERSION} (github.com/deanpcmad/streamelements)"
-          }
-
-          conn.request :json
+    def initialize(access_token:)
+      @access_token = access_token
+    end
 
-          conn.response :json, content_type: "application/json"
-        end
-      end
+    def channels
+      ChannelsResource.new(self)
+    end
 
+    def users
+      UsersResource.new(self)
+    end
 
-      def get_request(url, params: {}, headers: {})
-        handle_response connection.get(replace_channel(url), params, headers)
-      end
+    def activities
+      ActivitiesResource.new(self)
+    end
 
-      def post_request(url, body: {}, headers: {})
-        handle_response connection.post(replace_channel(url), body, headers)
-      end
+    def tips
+      TipsResource.new(self)
+    end
 
-      def put_request(url, body: {}, headers: {})
-        handle_response connection.put(replace_channel(url), body, headers)
-      end
+    def song_requests
+      SongRequestsResource.new(self)
+    end
 
-      def patch_request(url, body:, headers: {})
-        handle_response connection.patch(replace_channel(url), body, headers)
-      end
 
-      def delete_request(url, headers: {})
-        handle_response connection.delete(replace_channel(url), headers)
-      end
+    def connection
+      @connection ||= Faraday.new(BASE_URL) do |conn|
+        conn.request :authorization, :Bearer, access_token
 
-      def replace_channel(url)
-        url.gsub(":channel", StreamElements.config.channel)
-      end
+        conn.headers = {
+            "User-Agent" => "streamelements/v#{VERSION} (github.com/deanpcmad/streamelements)"
+          }
 
-      def handle_response(response)
-        case response.status
-        when 400
-          raise Error, "Error 400: Your request was malformed. '#{response.body["error"]}'"
-        when 401
-          raise Error, "Error 401: You did not supply valid authentication credentials. '#{response.body["error"]}'"
-        when 403
-          raise Error, "Error 403: You are not allowed to perform that action. '#{response.body["error"]}'"
-        when 404
-          raise Error, "Error 404: No results were found for your request. '#{response.body["error"]}'"
-        when 409
-          raise Error, "Error 409: Your request was a conflict. '#{response.body["error"]}'"
-        when 429
-          raise Error, "Error 429: Your request exceeded the API rate limit. '#{response.body["error"]}'"
-        when 500
-          raise Error, "Error 500: We were unable to perform the request due to server-side problems. '#{response.body["error"]}'"
-        when 503
-          raise Error, "Error 503: You have been rate limited for sending more than 20 requests per second. '#{response.body["error"]}'"
-        when 501
-          raise Error, "Error 501: This resource has not been implemented. '#{response.body["error"]}'"
-        when 204
-          return true
-        end
+        conn.request :json
 
-        response
+        conn.response :json, content_type: "application/json"
       end
-
     end
 
   end

data/lib/stream_elements/collection.rb

@@ -19,5 +19,17 @@ module StreamElements
       @data = data
       @total = total
     end
+
+    def each(&block)
+      data.each(&block)
+    end
+
+    def first
+      data.first
+    end
+
+    def last
+      data.last
+    end
   end
 end

data/lib/stream_elements/error_generator.rb

@@ -0,0 +1,128 @@
+module StreamElements
+  class ErrorGenerator < StandardError
+    attr_reader :http_status_code
+    attr_reader :error_code
+    attr_reader :error_message
+
+    def initialize(response_body, http_status_code)
+      @response_body = response_body
+      @http_status_code = http_status_code
+      set_error_values
+      super(build_message)
+    end
+
+    private
+
+    def set_error_values
+      @error_code = @response_body.dig("error")
+      @error_message = @response_body.dig("message")
+    end
+
+    def error_message
+      @error_message || @response_body.dig("error")
+    rescue NoMethodError
+      "An unknown error occurred."
+    end
+
+    def build_message
+      if error_code.nil?
+        return "Error #{@http_status_code}: #{error_message}"
+      end
+      "Error #{@http_status_code}: #{error_message} '#{error_message}'"
+    end
+  end
+
+  module Errors
+    class BadRequestError < ErrorGenerator
+      private
+
+      def error_message
+        "Your request was malformed."
+      end
+    end
+
+    class AuthenticationMissingError < ErrorGenerator
+      private
+
+      def error_message
+        "You did not supply valid authentication credentials."
+      end
+    end
+
+    class ForbiddenError < ErrorGenerator
+      private
+
+      def error_message
+        "You are not allowed to perform that action."
+      end
+    end
+
+    class EntityNotFoundError < ErrorGenerator
+      private
+
+      def error_message
+        "No results were found for your request."
+      end
+    end
+
+    class ConflictError < ErrorGenerator
+      private
+
+      def error_message
+        "Your request was a conflict."
+      end
+    end
+
+    class TooManyRequestsError < ErrorGenerator
+      private
+
+      def error_message
+        "Your request exceeded the API rate limit."
+      end
+    end
+
+    class InternalError < ErrorGenerator
+      private
+
+      def error_message
+        "We were unable to perform the request due to server-side problems."
+      end
+    end
+
+    class ServiceUnavailableError < ErrorGenerator
+      private
+
+      def error_message
+        "You have been rate limited for sending more than 20 requests per second."
+      end
+    end
+
+    class NotImplementedError < ErrorGenerator
+      private
+
+      def error_message
+        "This resource has not been implemented."
+      end
+    end
+  end
+
+  class ErrorFactory
+    HTTP_ERROR_MAP = {
+      400 => Errors::BadRequestError,
+      401 => Errors::AuthenticationMissingError,
+      403 => Errors::ForbiddenError,
+      404 => Errors::EntityNotFoundError,
+      409 => Errors::ConflictError,
+      429 => Errors::TooManyRequestsError,
+      500 => Errors::InternalError,
+      503 => Errors::ServiceUnavailableError,
+      501 => Errors::NotImplementedError
+    }.freeze
+
+    def self.create(response_body, http_status_code)
+      status = http_status_code
+      error_class = HTTP_ERROR_MAP[status] || ErrorGenerator
+      error_class.new(response_body, http_status_code) if error_class
+    end
+  end
+end

data/lib/stream_elements/objects/activity.rb

@@ -0,0 +1,4 @@
+module StreamElements
+  class Activity < Object
+  end
+end

data/lib/stream_elements/objects/song_request.rb

@@ -0,0 +1,4 @@
+module StreamElements
+  class SongRequest < Object
+  end
+end

data/lib/stream_elements/objects/tip.rb

@@ -0,0 +1,4 @@
+module StreamElements
+  class Tip < Object
+  end
+end

data/lib/stream_elements/objects/top_tip.rb

@@ -0,0 +1,4 @@
+module StreamElements
+  class TopTip < Object
+  end
+end

data/lib/stream_elements/objects/user.rb

@@ -0,0 +1,4 @@
+module StreamElements
+  class User < Object
+  end
+end

data/lib/stream_elements/resource.rb

@@ -0,0 +1,47 @@
+module StreamElements
+  class Resource
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    private
+
+    def get_request(url, params: {}, headers: {})
+      handle_response client.connection.get(url, params, headers)
+    end
+
+    def post_request(url, body: {}, headers: {})
+      handle_response client.connection.post(url, body, headers)
+    end
+
+    def put_request(url, body: {}, headers: {})
+      handle_response client.connection.put(url, body, headers)
+    end
+
+    def patch_request(url, body:, headers: {})
+      handle_response client.connection.patch(url, body, headers)
+    end
+
+    def delete_request(url, headers: {})
+      handle_response client.connection.delete(url, headers)
+    end
+
+    def handle_response(response)
+      return true if response.status == 204
+      return response unless error?(response)
+
+      raise_error(response)
+    end
+
+    def error?(response)
+      [ 400, 401, 403, 404, 409, 429, 500, 501, 503 ].include?(response.status) #|| response.body&.key?("error")
+    end
+
+    def raise_error(response)
+      error = StreamElements::ErrorFactory.create(response.body, response.status)
+      raise error if error
+    end
+  end
+end

data/lib/stream_elements/resources/activities.rb

@@ -0,0 +1,17 @@
+module StreamElements
+  class ActivitiesResource < Resource
+
+    def list(channel:, after:, before:, limit:, types:, **params)
+      attrs = { after: after, before: before, limit: limit, types: types }.merge(params)
+      response = get_request("activities/#{channel}", params: attrs)
+      Collection.from_response(response, type: Activity)
+    end
+
+    def top(channel:, period:, offset:, limit:, type:)
+      attrs = { period: period, offset: offset, limit: limit, type: type }
+      response = get_request("activities/#{channel}/top", params: attrs)
+      # Collection.from_response(response, type: TopActivity)
+    end
+
+  end
+end

data/lib/stream_elements/resources/channels.rb

@@ -0,0 +1,10 @@
+module StreamElements
+  class ChannelsResource < Resource
+
+    def me
+      response = get_request("channels/me")
+      Channel.new response.body
+    end
+
+  end
+end

data/lib/stream_elements/resources/song_requests.rb

@@ -0,0 +1,52 @@
+module StreamElements
+  class SongRequestsResource < Resource
+
+    def playing(channel:)
+      SongRequest.new get_request("songrequest/#{channel}/playing").body
+    end
+
+    def queue(channel:)
+      response = get_request("songrequest/#{channel}/queue")
+      Collection.from_response(response, type: SongRequest)
+    end
+
+    def history(channel:, **params)
+      response = get_request("songrequest/#{channel}/history", params: params)
+      Collection.from_response(response, type: SongRequest, name: "history")
+    end
+
+    def settings(channel:)
+      get_request("songrequest/#{channel}/settings").body
+    end
+
+    def update_settings(channel:, settings:)
+      response = put_request("songrequest/#{channel}/settings", body: settings)
+      response.success?
+    end
+
+    def add(channel:, video:)
+      SongRequest.new post_request("songrequest/#{channel}/queue", body: { video: video }).body
+    end
+
+    def pause(channel:)
+      response = post_request("songrequest/#{channel}/player/pause", body: {})
+      response.success?
+    end
+
+    def play(channel:)
+      response = post_request("songrequest/#{channel}/player/play", body: {})
+      response.success?
+    end
+
+    def volume(channel:, volume:)
+      response = post_request("songrequest/#{channel}/player/volume", body: {volume: volume})
+      response.success?
+    end
+
+    def skip(channel:)
+      response = post_request("songrequest/#{channel}/skip", body: {})
+      response.success?
+    end
+
+  end
+end

data/lib/stream_elements/resources/tips.rb

@@ -0,0 +1,20 @@
+module StreamElements
+  class TipsResource < Resource
+
+    def list(channel:, after:, sort:, limit:, **params)
+      attrs = { after: after, sort: sort, limit: limit }.merge(params)
+      response = get_request("tips/#{channel}", params: attrs)
+      Collection.from_response(response, type: Tip, name: "docs")
+    end
+
+    def retrieve(channel:, id:)
+      Tip.new get_request("tips/#{channel}/#{id}").body
+    end
+
+    def top(channel:)
+      response = get_request("tips/#{channel}/top")
+      Collection.from_response(response, type: TopTip)
+    end
+
+  end
+end

data/lib/stream_elements/resources/users.rb

@@ -0,0 +1,15 @@
+module StreamElements
+  class UsersResource < Resource
+
+    def current
+      response = get_request("users/current")
+      User.new response.body
+    end
+
+    def channels
+      response = get_request("users/channels")
+      Collection.from_response(response, type: Channel)
+    end
+
+  end
+end

data/lib/stream_elements/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StreamElements
-  VERSION = "0.2.0"
+  VERSION = "0.5.0"
 end

data/lib/stream_elements.rb

@@ -6,28 +6,27 @@ require "stream_elements/version"
 
 module StreamElements
 
-  autoload :Configuration, "stream_elements/configuration"
+  autoload :Error, "stream_elements/error"
+  autoload :Errors, "stream_elements/error_generator"
+  autoload :ErrorGenerator, "stream_elements/error_generator"
+  autoload :ErrorFactory, "stream_elements/error_generator"
+
   autoload :Client, "stream_elements/client"
   autoload :Collection, "stream_elements/collection"
-  autoload :Error, "stream_elements/error"
+  autoload :Resource, "stream_elements/resource"
   autoload :Object, "stream_elements/object"
 
-  class << self
-    attr_writer :config
-  end
-
-  def self.configure
-    yield(config) if block_given?
-  end
-
-  def self.config
-    @config ||= StreamElements::Configuration.new
-  end
-
-  autoload :Activity, "stream_elements/models/activity"
-  autoload :Tip, "stream_elements/models/tip"
-  autoload :SongRequest, "stream_elements/models/song_request"
-  autoload :User, "stream_elements/models/user"
-  autoload :Channel, "stream_elements/models/channel"
+  autoload :ActivitiesResource, "stream_elements/resources/activitys"
+  autoload :TipsResource, "stream_elements/resources/tips"
+  autoload :SongRequestsResource, "stream_elements/resources/song_requests"
+  autoload :UsersResource, "stream_elements/resources/users"
+  autoload :ChannelsResource, "stream_elements/resources/channels"
+
+  autoload :Activity, "stream_elements/objects/activity"
+  autoload :Tip, "stream_elements/objects/tip"
+  autoload :SongRequest, "stream_elements/objects/song_request"
+  autoload :User, "stream_elements/objects/user"
+  autoload :Channel, "stream_elements/objects/channel"
+  autoload :TopTip, "stream_elements/objects/top_tip"
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: streamelements
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Dean Perry
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-21 00:00:00.000000000 Z
+date: 2024-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -24,7 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
-description: 
+description:
 email:
 - deanperry@fastmail.com
 executables: []
@@ -38,14 +38,21 @@ files:
 - lib/stream_elements.rb
 - lib/stream_elements/client.rb
 - lib/stream_elements/collection.rb
-- lib/stream_elements/configuration.rb
 - lib/stream_elements/error.rb
-- lib/stream_elements/models/activity.rb
-- lib/stream_elements/models/channel.rb
-- lib/stream_elements/models/song_request.rb
-- lib/stream_elements/models/tip.rb
-- lib/stream_elements/models/user.rb
+- lib/stream_elements/error_generator.rb
 - lib/stream_elements/object.rb
+- lib/stream_elements/objects/activity.rb
+- lib/stream_elements/objects/channel.rb
+- lib/stream_elements/objects/song_request.rb
+- lib/stream_elements/objects/tip.rb
+- lib/stream_elements/objects/top_tip.rb
+- lib/stream_elements/objects/user.rb
+- lib/stream_elements/resource.rb
+- lib/stream_elements/resources/activities.rb
+- lib/stream_elements/resources/channels.rb
+- lib/stream_elements/resources/song_requests.rb
+- lib/stream_elements/resources/tips.rb
+- lib/stream_elements/resources/users.rb
 - lib/stream_elements/version.rb
 - lib/streamelements.rb
 - sig/streamelements.rbs
@@ -53,7 +60,7 @@ homepage: https://github.com/deanpcmad/streamelements
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -68,8 +75,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.1
-signing_key: 
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: Ruby library for the StreamElements API
 test_files: []

data/lib/stream_elements/configuration.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module StreamElements
-  class Configuration
-
-    attr_accessor :token
-    attr_accessor :channel
-
-    def initialize
-    end
-
-  end
-end

data/lib/stream_elements/models/activity.rb

@@ -1,21 +0,0 @@
-module StreamElements
-  class Activity < Object
-
-    class << self
-
-      def list(after:, before:, limit:, types:, **params)
-        attrs = { after: after, before: before, limit: limit, types: types }.merge(params)
-        response = Client.get_request("activities/:channel", params: attrs)
-        Collection.from_response(response, type: Activity)
-      end
-
-      def top(period:, offset:, limit:, type:)
-        attrs = { period: period, offset: offset, limit: limit, type: type }
-        response = Client.get_request("activities/:channel/top", params: attrs)
-        # Collection.from_response(response, type: TopActivity)
-      end
-
-    end
-
-  end
-end

data/lib/stream_elements/models/song_request.rb

@@ -1,56 +0,0 @@
-module StreamElements
-  class SongRequest < Object
-
-    class << self
-
-      def playing
-        SongRequest.new Client.get_request("songrequest/:channel/playing").body
-      end
-
-      def queue
-        response = Client.get_request("songrequest/:channel/queue")
-        Collection.from_response(response, type: SongRequest)
-      end
-
-      def history(**params)
-        response = Client.get_request("songrequest/:channel/history", params: params)
-        Collection.from_response(response, type: SongRequest, name: "history")
-      end
-
-      def settings
-        Client.get_request("songrequest/:channel/settings").body
-      end
-
-      def update_settings(settings:)
-        response = Client.put_request("songrequest/:channel/settings", body: settings)
-        response.success?
-      end
-
-      def add(video:)
-        SongRequest.new Client.post_request("songrequest/:channel/queue", body: { video: video }).body
-      end
-
-      def pause
-        response = Client.post_request("songrequest/:channel/player/pause", body: {})
-        response.success?
-      end
-
-      def play
-        response = Client.post_request("songrequest/:channel/player/play", body: {})
-        response.success?
-      end
-
-      def volume(volume:)
-        response = Client.post_request("songrequest/:channel/player/volume", body: {volume: volume})
-        response.success?
-      end
-
-      def skip
-        response = Client.post_request("songrequest/:channel/skip", body: {})
-        response.success?
-      end
-
-    end
-
-  end
-end

data/lib/stream_elements/models/tip.rb

@@ -1,23 +0,0 @@
-module StreamElements
-  class Tip < Object
-
-    class << self
-
-      def list(**params)
-        response = Client.get_request("tips/:channel", params: params)
-        Collection.from_response(response, type: Tip, name: "docs")
-      end
-
-      def retrieve(id:)
-        Tip.new Client.get_request("tips/:channel/#{id}").body
-      end
-
-      def top
-        response = Client.get_request("tips/:channel/top")
-        # Collection.from_response(response, type: TopTip)
-      end
-
-    end
-
-  end
-end

data/lib/stream_elements/models/user.rb

@@ -1,19 +0,0 @@
-module StreamElements
-  class User < Object
-
-    class << self
-
-      def current
-        response = Client.get_request("users/current")
-        User.new response.body
-      end
-
-      def channels
-        response = Client.get_request("users/channels")
-        Collection.from_response(response, type: Channel)
-      end
-
-    end
-
-  end
-end