kappa 0.1.1.pre → 0.1.2.pre

data/lib/kappa/base.rb

@@ -0,0 +1,9 @@
+class Class
+  def module_class(sym)
+    parts = name.split('::')
+    parts[-1] = sym
+    parts.inject(Kernel) { |const, part|
+      const.const_get(part)
+    }
+  end
+end

data/lib/kappa/channel.rb

@@ -0,0 +1,140 @@
+module Kappa
+  class ChannelBase
+    include IdEquality
+
+    def initialize(arg, connection)
+      @connection = connection
+
+      case arg
+        when Hash
+          parse(arg)
+        when String
+          json = @connection.get("channels/#{arg}")
+          parse(json)
+        else
+          raise ArgumentError
+      end
+    end
+  end
+end
+
+module Kappa::V2
+  # TODO:
+  # c.subscriptions
+  # c.start_commercial
+  # c.reset_stream_key
+  # c.foo = 'bar' ; c.save!
+  # Current user's channel
+  class Channel < Kappa::ChannelBase
+    def initialize(arg, connection = Connection.instance)
+      super(arg, connection)
+    end
+
+    def mature?
+      @mature
+    end
+
+    # TODO: Move these into derived classes?
+    def stream
+      # TODO: Use _links instead of hard-coding.
+      json = @connection.get("streams/#{@name}")
+      stream_json = json['stream']
+      Stream.new(stream_json, @connection)
+    end
+
+    def streaming?
+      stream.live?
+    end
+
+    #
+    # GET /channels/:channel/editors
+    # https://github.com/justintv/Twitch-API/blob/master/v2_resources/channels.md#get-channelschanneleditors
+    #
+    def editors
+      # TODO
+    end
+
+    #
+    # GET /channels/:channels/videos
+    # https://github.com/justintv/Twitch-API/blob/master/v2_resources/videos.md#get-channelschannelvideos
+    #
+    def videos(params = {})
+      # TODO
+    end
+
+    #
+    # GET /channels/:channel/follows
+    # https://github.com/justintv/Twitch-API/blob/master/v2_resources/channels.md#get-channelschannelfollows
+    # TODO: Warning: this set can be very large, this can run for very long time, recommend using :limit/:offset.
+    #
+    def followers(params = {})
+      limit = params[:limit] || 0
+
+      followers = []
+      ids = Set.new
+
+      @connection.paginated("channels/#{@name}/follows", params) do |json|
+        current_followers = json['follows']
+        current_followers.each do |follow_json|
+          user_json = follow_json['user']
+          user = User.new(user_json, @connection)
+          if ids.add?(user.id)
+            followers << user
+            if followers.count == limit
+              return followers
+            end
+          end
+        end
+
+        !current_followers.empty?
+      end
+
+      followers
+    end
+
+    # TODO: Requires authentication.
+    def subscribers
+    end
+
+    #
+    # GET /channels/:channel/subscriptions/:user
+    # https://github.com/justintv/Twitch-API/blob/master/v2_resources/subscriptions.md#get-channelschannelsubscriptionsuser
+    #
+    # TODO: Requires authentication.
+    def has_subscriber?(user)
+      # Support User object or username (string)
+    end
+
+    attr_reader :id
+    attr_reader :background_url
+    attr_reader :banner_url
+    attr_reader :created_at
+    attr_reader :stream_delay_sec
+    attr_reader :display_name
+    attr_reader :game_name
+    attr_reader :logo_url
+    attr_reader :name
+    attr_reader :status
+    attr_reader :updated_at
+    attr_reader :url
+    attr_reader :video_banner_url
+
+  private
+    def parse(hash)
+      @id = hash['_id']
+      @background_url = hash['background']
+      @banner_url = hash['banner']
+      @created_at = DateTime.parse(hash['created_at'])
+      @stream_delay_sec = hash['delay']
+      @display_name = hash['display_name']
+      @game_name = hash['game']
+      @logo_url = hash['logo']
+      @mature = hash['mature'] || false
+      @name = hash['name']
+      @status = hash['status']
+      @updated_at = DateTime.parse(hash['updated_at'])
+      @url = hash['url']
+      @video_banner_url = hash['video_banner']
+    end
+  end
+end

data/lib/kappa/connection.rb

@@ -0,0 +1,119 @@
+require 'httparty'
+require 'addressable/uri'
+require 'securerandom'
+require 'json'
+
+module Kappa
+  class ConnectionBase
+    include HTTParty
+    debug_output $stdout
+
+    def initialize(base_url = DEFAULT_BASE_URL)
+      @base_url = Addressable::URI.parse(base_url)
+
+      uuid = SecureRandom.uuid
+      # TODO: Use current library version.
+      @client_id = "Kappa-v1-#{uuid}"
+
+      @last_request_time = Time.now - RATE_LIMIT_SEC
+    end
+
+    def self.instance
+      @connection ||= self.class_eval do
+        self.new
+      end
+    end
+
+    def get(path, query = nil)
+      request_url = @base_url + path
+
+      # Handle non-JSON response
+      # Handle invalid JSON
+      # Handle non-200 codes
+
+      headers = {
+        'Client-ID' => @client_id,
+      }.merge(custom_headers)
+
+      response = rate_limit do
+        self.class.get(request_url, :headers => headers, :query => query)
+      end
+
+      json = response.body
+      return JSON.parse(json)
+    end
+
+    def paginated(path, params = {})
+      limit = [params[:limit] || 100, 100].min
+      offset = params[:offset] || 0
+
+      path_uri = Addressable::URI.parse(path)
+      query = { 'limit' => limit, 'offset' => offset }
+      path_uri.query_values ||= {}
+      path_uri.query_values = path_uri.query_values.merge(query)
+
+      request_url = path_uri.to_s
+
+      params = params.dup
+      params.delete(:limit)
+      params.delete(:offset)
+
+      # TODO: Hande request retry.
+      loop do
+        json = get(request_url, params)
+
+        if json['error'] && (json['status'] == 503)
+          break
+        end
+
+        break if !yield(json)
+
+        links = json['_links']
+        next_url = links['next']
+
+        next_uri = Addressable::URI.parse(next_url)
+        offset = next_uri.query_values['offset'].to_i
+
+        total = json['_total']
+        break if total && (offset > total)
+
+        request_url = next_url
+      end
+    end
+
+  private
+    def rate_limit
+      delta = Time.now - @last_request_time
+      delay = [RATE_LIMIT_SEC - delta, 0].max
+
+      sleep delay if delay > 0
+
+      begin
+        return yield
+      ensure
+        @last_request_time = Time.now
+      end
+    end
+
+    RATE_LIMIT_SEC = 1
+    DEFAULT_BASE_URL = 'https://api.twitch.tv/kraken/'
+  end
+end
+
+module Kappa::V2
+  class Connection < Kappa::ConnectionBase
+  private
+    def custom_headers
+      { 'Accept' => 'application/vnd.twitchtv.v2+json' }
+    end
+  end
+end
+
+module Kappa::V3
+  class Connection < Kappa::ConnectionBase
+  private
+    def custom_headers
+      { 'Accept' => 'application/vnd.twitchtv.v3+json' }
+    end
+  end
+end

data/lib/kappa/game.rb

@@ -0,0 +1,122 @@
+module Kappa
+  class GameBase
+    include IdEquality
+
+    def initialize(arg)
+      case arg
+        when Hash
+          parse(arg)
+        else
+          raise ArgumentError
+      end
+    end
+  end
+
+  class GameSuggestionBase
+    include IdEquality
+
+    def initialize(arg)
+      case arg
+        when Hash
+          parse(arg)
+        else
+          raise ArgumentError
+      end
+    end
+  end
+end
+
+module Kappa::V2
+  class Game < Kappa::GameBase
+    attr_reader :id
+    attr_reader :name
+    attr_reader :giantbomb_id
+    attr_reader :box_images
+    attr_reader :logo_images
+    attr_reader :channel_count
+    attr_reader :viewer_count
+
+  private
+    def parse(hash)
+      @channel_count = hash['channels']
+      @viewer_count = hash['viewers']
+
+      game = hash['game']
+      @id = game['_id']
+      @name = game['name']
+      @giantbomb_id = game['giantbomb_id']
+      @box_images = Images.new(game['box'])
+      @logo_images = Images.new(game['logo'])
+    end
+  end
+
+  class GameSuggestion < Kappa::GameSuggestionBase
+    attr_reader :id
+    attr_reader :name
+    attr_reader :giantbomb_id
+    attr_reader :popularity
+    attr_reader :box_images
+    attr_reader :logo_images
+
+  private
+    def parse(hash)
+      @id = hash['_id']
+      @name = hash['name']
+      @giantbomb_id = hash['giantbomb_id']
+      @popularity = hash['popularity']
+      @box_images = Images.new(hash['box'])
+      @logo_images = Images.new(hash['logo'])
+    end
+  end
+
+  class Games
+    #
+    # GET /games/top
+    # https://github.com/justintv/Twitch-API/blob/master/v2_resources/games.md#get-gamestop
+    #
+    def top(params = {})
+      limit = params[:limit] || 0
+
+      games = []
+      ids = Set.new
+
+      @conn.paginated('games/top', params) do |json|
+        current_games = json['top']
+        current_games.each do |game_json|
+          game = Game.new(game_json)
+          if ids.add?(game.id)
+            games << game
+            if games.count == limit
+              return games
+            end
+          end
+        end
+      end
+
+      games
+    end
+    
+    #
+    # GET /search/games
+    # https://github.com/justintv/Twitch-API/blob/master/v2_resources/search.md#get-searchgames
+    #
+    def search(params = {})
+      live = params[:live] || false
+      name = params[:name]
+
+      games = []
+      ids = Set.new
+
+      json = @conn.get('search/games', :query => name, :type => 'suggest', :live => live)
+      all_games = json['games']
+      all_games.each do |game_json|
+        game = GameSuggestion.new(game_json)
+        if ids.add?(game.id)
+          games << game
+        end
+      end
+
+      games
+    end
+  end
+end

data/lib/kappa/id_equality.rb

@@ -0,0 +1,16 @@
+module Kappa
+  module IdEquality
+    def hash
+      @id.hash
+    end
+
+    def eql?(other)
+      other && (self.class == other.class) && (self.id == other.id)
+    end
+
+    def ==(other)
+      eql?(other)
+    end
+  end
+end
+

data/lib/kappa/images.rb

@@ -0,0 +1,33 @@
+module Kappa
+  class ImagesBase
+    def initialize(arg)
+      case arg
+        when Hash
+          parse(arg)
+        else
+          raise ArgumentError
+      end
+    end
+  end
+end
+
+module Kappa::V2
+  class Images < Kappa::ImagesBase
+    def url(width, height)
+      @template_url.gsub('{width}', width.to_s, '{height}', height.to_s)
+    end
+
+    attr_reader :large_url
+    attr_reader :medium_url
+    attr_reader :small_url
+    attr_reader :template_url
+
+  private
+    def parse(hash)
+      @large_url = hash['large']
+      @medium_url = hash['medium']
+      @small_url = hash['small']
+      @template_url = hash['template']
+    end
+  end
+end

data/lib/kappa/stream.rb

@@ -0,0 +1,151 @@
+require 'set'
+
+module Kappa
+  class StreamBase
+    include IdEquality
+
+    def initialize(hash, connection = self.class.default_connection)
+      @connection = connection
+      parse(hash)
+    end
+
+    def self.get(stream_name, connection = default_connection)
+      json = connection.get("streams/#{stream_name}")
+      stream = json['stream']
+      if json['status'] == 404 || !stream
+        nil
+      else
+        new(stream, connection)
+      end
+    end
+
+  private
+    def self.default_connection
+      self.class.module_class(:Connection).instance
+    end
+  end
+end
+
+module Kappa::V2
+  class Stream < Kappa::StreamBase
+    attr_reader :id
+    attr_reader :broadcaster
+    attr_reader :game_name
+    attr_reader :name
+    attr_reader :viewer_count
+    attr_reader :preview_url
+    attr_reader :channel
+
+  private
+    def parse(hash)
+      @id = hash['_id']
+      @broadcaster = hash['broadcaster']
+      @game_name = hash['game']
+      @name = hash['name']
+      @viewer_count = hash['viewers']
+      @preview_url = hash['preview']
+      @channel = Channel.new(hash['channel'], @connection)
+    end
+  end
+
+  class Streams
+    def self.all
+    end
+
+    #
+    # GET /streams
+    # https://github.com/justintv/Twitch-API/blob/master/v2_resources/streams.md
+    # :game (single, string), :channel (string array), :limit (int), :offset (int), :embeddable (bool), :hls (bool)
+    # TODO: Support Kappa::Vx::Game object for the :game param.
+    # TODO: Support Kappa::Vx::Channel object for the :channel param.
+    #
+    def self.where(args)
+      check = args.dup
+      check.delete(:limit)
+      check.delete(:offset)
+      raise ArgumentError if check.empty?
+
+      params = {}
+
+      if args[:channel]
+        params[:channel] = args[:channel].join(',')
+      end
+
+      if args[:game]
+        params[:game] = args[:game]
+      end
+
+      limit = args[:limit]
+      if limit && (limit < 25)
+        params[:limit] = limit
+      else
+        params[:limit] = 25
+        limit = 0
+      end
+
+      streams = []
+      ids = Set.new
+
+      connection = Connection.instance
+      connection.paginated('streams', params) do |json|
+        current_streams = json['streams']
+        current_streams.each do |stream_json|
+          stream = Stream.new(stream_json, connection)
+          if ids.add?(stream.id)
+            streams << stream
+            if streams.count == limit
+              return streams
+            end
+          end
+        end
+
+        !current_streams.empty?
+      end
+
+      streams
+    end
+
+    #
+    # GET /streams/featured
+    # https://github.com/justintv/Twitch-API/blob/master/v2_resources/streams.md#get-streamsfeatured
+    #
+    def self.featured(params = {})
+      limit = params[:limit] || 0
+
+      streams = []
+      ids = Set.new
+
+      connection = Connection.instance
+      connection.paginated('streams/featured', params) do |json|
+        current_streams = json['featured']
+        current_streams.each do |featured_json|
+          # TODO: Capture more information from the featured_json structure (need a FeaturedStream class?)
+          stream_json = featured_json['stream']
+          stream = Stream.new(stream_json, connection)
+          if ids.add?(stream.id)
+            streams << stream
+            if streams.count == limit
+              return streams
+            end
+          end
+        end
+
+        !current_streams.empty?
+      end
+
+      streams
+    end
+  end
+end
+
+module Kappa::V3
+  class Stream < Kappa::StreamBase
+    def initialize(arg, connection = Connection.instance)
+      super(arg, connection)
+    end
+
+  private
+    def parse(hash)
+    end
+  end
+end