yt-core 0.0.1 → 0.1.0

data/lib/yt/playlist.rb

@@ -0,0 +1,75 @@
+module Yt
+  # Provides methods to interact with YouTube playlists.
+  # @see https://developers.google.com/youtube/v3/docs/playlists
+  class Playlist < Resource
+    # @!attribute [r] title
+    #   @return [String] the playlist’s title.
+    has_attribute :title, in: :snippet
+
+    # @!attribute [r] description
+      # @return [String] the playlist’s description.
+    has_attribute :description, in: :snippet
+
+    # @!attribute [r] published_at
+    # @return [Time] the date and time that the playlist was created.
+    has_attribute :published_at, in: :snippet, type: Time
+
+    # @!attribute [r] thumbnails
+    # @return [Hash<String, Hash>] the thumbnails associated with the playlist.
+    has_attribute :thumbnails, in: :snippet
+
+    # @!attribute [r] channel_id
+    # @return [String] the ID of the channel that published the playlist.
+    has_attribute :channel_id, in: :snippet
+
+    # @!attribute [r] channel_title
+    # @return [String] the title of the channel that published the playlist.
+    has_attribute :channel_title, in: :snippet
+
+    # has_attribute :default_language, in: :snippet not sure how to set to test
+    # has_attribute :localized, in: :snippet not yet implemented
+    # has_attribute :tags, in: :snippet not sure how to set to test
+
+    # @!attribute [r] privacy_status
+    # @return [String] the playlist’s privacy status. Valid values are:
+    #   +"private"+, +"public"+, and +"unlisted"+.
+    has_attribute :privacy_status, in: :status
+
+    # @!attribute [r] item_count
+    # @return [<Integer>] the number of videos in the playlist.
+    has_attribute :item_count, in: :content_details, type: Integer
+
+    # Returns the URL of the playlist’s thumbnail.
+    # @param [Symbol, String] size The size of the playlist’s thumbnail.
+    # @return [String] if +size+ is +:default+, the URL of a 120x90px image.
+    # @return [String] if +size+ is +:medium+, the URL of a 320x180px image.
+    # @return [String] if +size+ is +:high+, the URL of a 480x360px image.
+    # @return [String] if +size+ is +:standard+, the URL of a 640x480px image.
+    # @return [String] if +size+ is +:maxres+, the URL of a 1280x720px image.
+    # @return [nil] if the +size+ is none of the above.
+    def thumbnail_url(size = :default)
+      thumbnails.fetch(size.to_s, {})['url']
+    end
+
+    # @return [String] the canonical form of the playlist’s URL.
+    def canonical_url
+      "https://www.youtube.com/playlist?list=#{id}"
+    end
+
+    # @return [Yt::Relation<Yt::PlaylistItem>] the items of the playlist.
+    def items
+      @items ||= Relation.new(PlaylistItem, playlist_id: id) do |options|
+        fetch '/youtube/v3/playlistItems', playlist_items_params(options)
+      end
+    end
+
+    # @return [Yt::Relation<Yt::Video>] the videos of the playlist.
+    def videos
+      @videos ||= Relation.new(Video, playlist_id: id) do |options|
+        params = playlist_items_params(options.merge parts: [:content_details])
+        items = fetch '/youtube/v3/playlistItems', params
+        videos_for items, 'contentDetails', options
+      end
+    end
+  end
+end

data/lib/yt/playlist_item.rb

@@ -0,0 +1,59 @@
+module Yt
+  # Provides methods to interact with YouTube playlist items.
+  # @see https://developers.google.com/youtube/v3/docs/playlistItems
+  class PlaylistItem < Resource
+    # @!attribute [r] title
+    #   @return [String] the item’s title.
+    has_attribute :title, in: :snippet
+
+    # @!attribute [r] description
+      # @return [String] the item’s description.
+    has_attribute :description, in: :snippet
+
+    # @!attribute [r] published_at
+    # @return [Time] the date and time that the item was added to the playlist.
+    has_attribute :published_at, in: :snippet, type: Time
+
+    # @!attribute [r] thumbnails
+    # @return [Hash<String, Hash>] the thumbnails associated with the item.
+    has_attribute :thumbnails, in: :snippet
+
+    # @!attribute [r] channel_id
+    # @return [String] the ID of the channel that the playlist belongs to.
+    has_attribute :channel_id, in: :snippet
+
+    # @!attribute [r] channel_title
+    # @return [String] the title of the channel that the playlist belongs to.
+    has_attribute :channel_title, in: :snippet
+
+    # @!attribute [r] playlist_id
+    # @return [String] the ID of the playlist that the item belongs to.
+    has_attribute :playlist_id, in: :snippet
+
+    # @!attribute [r] position
+    # @return [Integer] the order in which the item appears in the playlist.
+    #   The value uses a zero-based index so the first item has a position of 0.
+    has_attribute :position, in: :snippet, type: Integer
+
+    # @!attribute [r] video_id
+    # @return [String] the ID of the video that the item refers to.
+    has_attribute :video_id, in: %i(snippet resource_id)
+
+    # @!attribute [r] privacy_status
+    # @return [String] the item’s privacy status. Valid values are:
+    #   +"private"+, +"public"+, and +"unlisted"+.
+    has_attribute :privacy_status, in: :status
+
+    # Returns the URL of the item’s thumbnail.
+    # @param [Symbol, String] size The size of the item’s thumbnail.
+    # @return [String] if +size+ is +:default+, the URL of a 120x90px image.
+    # @return [String] if +size+ is +:medium+, the URL of a 320x180px image.
+    # @return [String] if +size+ is +:high+, the URL of a 480x360px image.
+    # @return [String] if +size+ is +:standard+, the URL of a 640x480px image.
+    # @return [String] if +size+ is +:maxres+, the URL of a 1280x720px image.
+    # @return [nil] if the +size+ is none of the above.
+    def thumbnail_url(size = :default)
+      thumbnails.fetch(size.to_s, {})['url']
+    end
+  end
+end

data/lib/yt/relation.rb

@@ -0,0 +1,100 @@
+module Yt
+  # Provides methods to iterate through collections of YouTube resources.
+  # @private
+  class Relation
+    include Enumerable
+
+    # @param [Class] item_class the class of objects to initialize when
+    #   iterating through a collection of YouTube resources.
+    # @yield [Hash] the options to change which items to iterate through.
+    def initialize(item_class, options = {}, &item_block)
+      @options = {parts: %i(id), limit: Float::INFINITY, item_class: item_class}
+      @options.merge! options
+      @item_block = item_block
+    end
+
+    # Let's start without memoizing
+    def each
+      @last_index = 0
+      while next_item = find_next
+        break if @last_index > @options[:limit]
+        yield next_item
+      end
+    end
+
+    def find_next
+      @items ||= []
+      if @items[@last_index].nil? && more_pages?
+        response = Response.new(@options, &@item_block).run
+        more_items = response.body['items'].map do |item|
+          @options[:item_class].new attributes_for_new_item(item)
+        end
+        @options.merge! offset: response.body['nextPageToken']
+        @items.concat more_items
+      end
+      @items[(@last_index +=1) -1]
+    end
+
+    def more_pages?
+      @last_index.zero? || !@options[:offset].nil?
+    end
+
+    def attributes_for_new_item(item)
+      {}.tap do |matching_parts|
+        item.each_key do |key|
+          part = key.gsub(/([A-Z])/) { "_#{$1.downcase}" }.to_sym
+          if @options[:parts].include? part
+            matching_parts[part] = item[key]
+          end
+        end
+      end
+    end
+
+    # @return [Integer] the estimated number of items in the collection.
+    def size
+      size_options = @options.merge parts: %i(id), limit: 1
+      @response = Response.new(size_options, &@item_block).run
+      [@response.body['pageInfo']['totalResults'], @options[:limit]].min
+    end
+
+    # Specifies which parts of the resource to fetch when hitting the data API.
+    # @param [Array<Symbol>] parts The parts to fetch.
+    # @return [Yt::Relation] itself.
+    def select(*parts)
+      if @options[:parts] != parts + %i(id)
+        @items = nil
+        @options.merge! parts: (parts + %i(id))
+      end
+      self
+    end
+
+    # Specifies which items to fetch when hitting the data API.
+    # @param [Hash<Symbol, String>] conditions The conditions for the items.
+    # @return [Yt::Relation] itself.
+    def where(conditions = {})
+      if @options[:conditions] != conditions
+        @items = []
+        @options.merge! conditions: conditions
+      end
+      self
+    end
+
+    # Specifies how many items to fetch when hitting the data API.
+    # @param [Integer] max_results The maximum number of items to fetch.
+    # @return [Yt::Relation] itself.
+    def limit(max_results)
+      @options.merge! limit: max_results
+      self
+    end
+
+    # @return [String] a representation of the Yt::Relation instance.
+    def inspect
+      entries = take(3).map!(&:inspect)
+      if entries.size == 3
+        entries[2] = '...'
+      end
+
+      "#<#{self.class.name} [#{entries.join(', ')}]>"
+    end
+  end
+end

data/lib/yt/resource.rb

@@ -0,0 +1,85 @@
+module Yt
+  # Provides a base class for YouTube channels, videos, playlists and items.
+  # This is an abstract class and should not be instantiated directly.
+  class Resource
+    # @param [Hash<Symbol, String>] data the options to initialize a resource.
+    # @option data [String] :id The unique ID of a YouTube resource.
+    def initialize(data = {})
+      @data = data
+      @selected_data_parts = nil
+    end
+
+    # @return [String] the resource’s unique ID.
+    def id
+      @data[:id]
+    end
+
+    # @return [Hash] the resource’s data.
+    attr_reader :data
+
+    # @return [String] a representation of the resource instance.
+    def inspect
+      "#<#{self.class} @id=#{id}>"
+    end
+
+    # Specifies which parts of the resource to fetch when hitting the data API.
+    # @param [Array<Symbol>] parts The parts to fetch.
+    # @return [Yt::Resource] itself.
+    def select(*parts)
+      @selected_data_parts = parts
+      self
+    end
+
+    # @return [Yt::Relation<Yt::Video>] the videos matching the conditions.
+    def self.where(conditions = {})
+      @where ||= Relation.new(self) do |options|
+        slicing_conditions_every(50) do |slice_options|
+          fetch resources_path, where_params(slice_options)
+        end
+      end
+      @where.where conditions
+    end
+
+  private
+
+    def camelize(part)
+      part.to_s.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+    end
+
+    def self.has_attribute(name, options = {}, &block)
+      define_method name do
+        keys = Array(options[:in]) + [name]
+        part = keys.shift
+        value = @data[part] || fetch_part(part)
+        keys.each{|key| value = value[camelize key]}
+        value = type_cast value, options[:type]
+        block_given? ? instance_exec(value, &block) : value
+      end
+    end
+
+    def fetch_part(required_part)
+      resources = Relation.new(self.class, ids: [id]) do |options|
+        fetch resources_path, resource_params(options)
+      end
+
+      parts = @selected_data_parts || [required_part]
+      if (resource = resources.select(*parts).first)
+        parts.each{|part| @data[part] = resource.data[part]}
+        @data[required_part]
+      else
+        raise NoItemsError
+      end
+    end
+
+    def type_cast(value, type)
+      case [type]
+      when [Time]
+        Time.parse value
+      when [Integer]
+        value.to_i
+      else
+        value
+      end
+    end
+  end
+end

data/lib/yt/response.rb

@@ -0,0 +1,91 @@
+module Yt
+  # @private
+  class Response
+    def initialize(options, &block)
+      @options = options
+      @block = block
+    end
+
+    def run
+      instance_exec @options, &@block
+    end
+
+  private
+
+    def fetch(path, params)
+      HTTPRequest.new(path: path, params: params).run
+    end
+
+    def resources_path
+      @options[:item_class].name.split('::').last.gsub(/^(\w{1})(.*)/) do
+        "/youtube/v3/#{$1.downcase}#{$2}s"
+      end
+    end
+
+    def where_params(options)
+      ids = options[:conditions].fetch(:id, []).join ','
+      default_params(options).merge id: ids
+    end
+
+    def channel_playlists_params(options)
+      default_params(options).merge channel_id: options[:channel_id]
+    end
+
+    def channel_videos_params(options)
+      params = {channel_id: options[:channel_id], order: :date, type: :video}
+      default_params(options.merge parts: %i(id)).merge params
+    end
+
+    def playlist_items_params(options)
+      default_params(options).merge playlist_id: options[:playlist_id]
+    end
+
+    def resource_params(options)
+      default_params(options).merge id: options[:ids].join(',')
+    end
+
+    def default_params(options)
+      {}.tap do |params|
+        params[:max_results] = 50
+        params[:key] = Yt.configuration.api_key
+        params[:part] = options[:parts].join ','
+        params[:page_token] = options[:offset]
+      end
+    end
+
+    def slicing_conditions_every(size, &block)
+      slices = @options[:conditions].fetch(:id, []).each_slice size
+      slices.inject(nil) do |response, ids|
+        slice_options = @options.merge conditions: {id: ids}
+        response = combine_slices response, yield(slice_options)
+      end
+    end
+
+    def combine_slices(total, partial)
+      if total
+        total.body['items'] += partial.body['items']
+        total_results = partial.body['pageInfo']['totalResults']
+        total.body['pageInfo']['totalResults'] += total_results
+        total
+      else
+        partial
+      end
+    end
+
+    # Expands the resultset into a collection of videos by fetching missing
+    # parts, eventually with an additional HTTP request.
+    def videos_for(items, key, options)
+      items.body['items'].map{|item| item['id'] = item[key]['videoId']}
+
+      if options[:parts] == %i(id)
+        items
+      else
+        options[:ids] = items.body['items'].map{|item| item['id']}
+        options[:offset] = nil
+        fetch('/youtube/v3/videos', resource_params(options)).tap do |response|
+          response.body['nextPageToken'] = items.body['nextPageToken']
+        end
+      end
+    end
+  end
+end

data/lib/yt/video.rb

@@ -0,0 +1,216 @@
+module Yt
+  # Provides methods to interact with YouTube videos.
+  # @see https://developers.google.com/youtube/v3/docs/videos
+  class Video < Resource
+    # @!attribute [r] title
+    # @return [String] the video’s title. Has a maximum length of 100 characters
+    #   and may contain all valid UTF-8 characters except < and >.
+    has_attribute :title, in: :snippet
+
+    # @!attribute [r] description
+    # @return [String] the video’s description. Has a maximum length of 5000
+    #   bytes and may contain all valid UTF-8 characters except < and >.
+    has_attribute :description, in: :snippet
+
+    # @!attribute [r] published_at
+    # @return [Time] the date and time that the video was published. Note that
+    #   this time might be different than the time that the video was uploaded.
+    #   For example, if a video is uploaded as a private video and then made
+    #   public at a later time, this property will specify the time that the
+    #   video was made public.
+    has_attribute :published_at, in: :snippet, type: Time
+
+    # @!attribute [r] thumbnails
+    # @return [Hash<String, Hash>] the thumbnails associated with the video.
+    has_attribute :thumbnails, in: :snippet
+
+    # @!attribute [r] channel_id
+    # @return [String] the ID of the channel that the video was uploaded to.
+    has_attribute :channel_id, in: :snippet
+
+    # @!attribute [r] channel_title
+    # @return [String] the title of the channel that the video was uploaded to.
+    has_attribute :channel_title, in: :snippet
+
+    # @!attribute [r] tags
+    # @return [Array<String>] the list of tags associated with the video.
+    has_attribute :tags, in: :snippet
+
+    # @!attribute [r] category_id
+    # @return [Integer] the ID of the associated YouTube video category.
+    # @see https://developers.google.com/youtube/v3/docs/videoCategories/list
+    has_attribute :category_id, in: :snippet, type: Integer
+
+    # @!attribute [r] live_broadcast_content
+    # @return [String] whether the video is an upcoming/active live broadcast.
+    #   Valid values are: +"live"+, +"none"+, +"upcoming"+.
+    has_attribute :live_broadcast_content, in: :snippet
+
+    # has_attribute :default_language, in: :snippet not sure how to set to test
+    # has_attribute :localized, in: :snippet not yet implemented
+    # has_attribute :default_audio_language, in: :snippet not sure how to test
+
+    # @!attribute [r] upload_status
+    # @return [String] the status of the uploaded video. Valid values are:
+    #   +"deleted"+, +"failed"+, +"processed"+, +"rejected"+, and +"unlisted"+.
+    has_attribute :upload_status, in: :status
+
+    # @!attribute [r] privacy_status
+    # @return [String] the video’s privacy status. Valid values are:
+    #   +"private"+, +"public"+, and +"unlisted"+.
+    has_attribute :privacy_status, in: :status
+
+    # @!attribute [r] license
+    # @return [String] the video’s license. Valid values are:
+    #   +"creative_common"+ and +"youtube"+.
+    has_attribute :license, in: :status
+
+    # @!attribute [r] embeddable
+    # @return [Boolean] whether the video can be embedded on another website.
+    has_attribute :embeddable, in: :status
+
+    # @!attribute [r] public_stats_viewable
+    # @return [Boolean] whether the extended video statistics on the video’s
+    #   watch page are publicly viewable.
+    has_attribute :public_stats_viewable, in: :status
+
+    # has_attribute :failure_reason, in: :status not yet implemented
+    # has_attribute :rejection_reason, in: :status not yet implemented
+    # has_attribute :publish_at, in: :status not yet implemented
+
+    # @!attribute [r] view_count
+    # @return [<Integer>] the number of times the video has been viewed.
+    has_attribute :view_count, in: :statistics, type: Integer
+
+    # @!attribute [r] like_count
+    # @return [<Integer>] the number of users who have liked the video.
+    has_attribute :like_count, in: :statistics, type: Integer
+
+    # @!attribute [r] dislike_count
+    # @return [<Integer>] the number of users who have disliked the video.
+    has_attribute :dislike_count, in: :statistics, type: Integer
+
+    # @!attribute [r] comment_count
+    # @return [<Integer>] the number of comments for the video.
+    has_attribute :comment_count, in: :statistics, type: Integer
+
+    # @!attribute [r] duration
+    # @return [<String>] the length of the video as an ISO 8601 duration.
+    has_attribute :duration, in: :content_details
+
+    # @!attribute [r] dimension
+    # @return [String] whether the video is available in 3D or in 2D.
+    #   Valid values are: +"2d"+ and +"3d".
+    has_attribute :dimension, in: :content_details
+
+    # @!attribute [r] definition
+    # @return [String] whether the video is available in high definition or only
+    #   in standard definition. Valid values are: +"sd"+ and +"hd".
+    has_attribute :definition, in: :content_details
+
+    # @!attribute [r] caption
+    # @return [Boolean] whether captions are available for the video.
+    has_attribute :caption, in: :content_details do |captioned|
+      captioned == 'true'
+    end
+
+    # @!attribute [r] licensed_content
+    # @return [Boolean] whether the video represents licensed content, which
+    #   means that the content was uploaded to a channel linked to a YouTube
+    #   content partner and then claimed by that partner.
+    has_attribute :licensed_content, in: :content_details
+
+    # @!attribute [r] projection
+    # @return [String] the projection format of the video. Valid values are:
+    #   +"360"+ and +"rectangular".
+    has_attribute :projection, in: :content_details
+
+    # has_attribute :has_custom_thumbnail, in: :content_details to do
+    # has_attribute :content_rating, in: :content_details to do
+
+    # Returns the URL of the video’s thumbnail.
+    # @param [Symbol, String] size The size of the video’s thumbnail.
+    # @return [String] if +size+ is +:default+, the URL of a 120x90px image.
+    # @return [String] if +size+ is +:medium+, the URL of a 320x180px image.
+    # @return [String] if +size+ is +:high+, the URL of a 480x360px image.
+    # @return [String] if +size+ is +:standard+, the URL of a 640x480px image.
+    # @return [String] if +size+ is +:maxres+, the URL of a 1280x720px image.
+    # @return [nil] if the +size+ is none of the above.
+    def thumbnail_url(size = :default)
+      thumbnails.fetch(size.to_s, {})['url']
+    end
+
+    # @return [String] the canonical form of the video’s URL.
+    def canonical_url
+      "https://www.youtube.com/watch?v=#{id}"
+    end
+
+    # @return [Hash<Integer, String>] the list of YouTube video categories.
+    CATEGORIES = {
+       1 => 'Film & Animation', 2 => 'Autos & Vehicles', 10 => 'Music',
+      15 => 'Pets & Animals', 17 => 'Sports', 18 => 'Short Movies',
+      19 => 'Travel & Events', 20 => 'Gaming', 21 => 'Videoblogging',
+      22 => 'People & Blogs', 23 => 'Comedy', 24 => 'Entertainment',
+      25 => 'News & Politics', 26 => 'Howto & Style', 27 => 'Education',
+      28 => 'Science & Technology', 29 => 'Nonprofits & Activism',
+      30 => 'Movies', 31 => 'Anime/Animation', 32 => 'Action/Adventure',
+      33 => 'Classics', 34 => 'Comedy', 35 => 'Documentary', 36 => 'Drama',
+      37 => 'Family', 38 => 'Foreign', 39 => 'Horror', 40 => 'Sci-Fi/Fantasy',
+      41 => 'Thriller', 42 => 'Shorts', 43 => 'Shows', 44 => 'Trailers',
+    }
+
+    # @return [String] the title of the associated YouTube video category.
+    def category_title
+      CATEGORIES[category_id]
+    end
+
+    # @return [<Integer>] the length of the video in seconds.
+    def seconds
+      to_seconds duration
+    end
+
+    # @return [<String>] the length of the video as an ISO 8601 time, HH:MM:SS.
+    def length
+      hh, mm, ss = seconds / 3600, seconds / 60 % 60, seconds % 60
+      [hh, mm, ss].map{|t| t.to_s.rjust(2,'0')}.join(':')
+    end
+
+    # @return [Yt::Channel] the channel the video belongs to.
+    def channel
+      @channel ||= Channel.new id: channel_id
+    end
+
+  private
+
+    # @return [Integer] the duration of the resource as reported by YouTube.
+    # @see https://developers.google.com/youtube/v3/docs/videos
+    #
+    # According to YouTube documentation, the value is an ISO 8601 duration
+    # in the format PT#M#S, in which the letters PT indicate that the value
+    # specifies a period of time, and the letters M and S refer to length in
+    # minutes and seconds, respectively. The # characters preceding the M and
+    # S letters are both integers that specify the number of minutes (or
+    # seconds) of the video. For example, a value of PT15M51S indicates that
+    # the video is 15 minutes and 51 seconds long.
+    #
+    # The ISO 8601 duration standard, though, is not +always+ respected by
+    # the results returned by YouTube API. For instance: video 2XwmldWC_Ls
+    # reports a duration of 'P1W2DT6H21M32S', which is to be interpreted as
+    # 1 week, 2 days, 6 hours, 21 minutes, 32 seconds. Mixing weeks with
+    # other time units is not strictly part of ISO 8601; in this context,
+    # weeks will be interpreted as "the duration of 7 days". Similarly, a
+    # day will be interpreted as "the duration of 24 hours".
+    # Video tPEE9ZwTmy0 reports a duration of 'PT2S'. Skipping time units
+    # such as minutes is not part of the standard either; in this context,
+    # it will be interpreted as "0 minutes and 2 seconds".
+    def to_seconds(iso8601_duration)
+      match = iso8601_duration.match %r{^P(?:|(?<weeks>\d*?)W)(?:|(?<days>\d*?)D)(?:|T(?:|(?<hours>\d*?)H)(?:|(?<min>\d*?)M)(?:|(?<sec>\d*?)S))$}
+      weeks = (match[:weeks] || '0').to_i
+      days = (match[:days] || '0').to_i
+      hours = (match[:hours] || '0').to_i
+      minutes = (match[:min] || '0').to_i
+      seconds = (match[:sec]).to_i
+      (((((weeks * 7) + days) * 24 + hours) * 60) + minutes) * 60 + seconds
+    end
+  end
+end

data/yt-core.gemspec

@@ -1,23 +1,35 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'yt-core/version'
+require 'yt/core/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "yt-core"
-  spec.version       = YtCore::VERSION
-  spec.authors       = ["claudiob"]
-  spec.email         = ["claudiob@gmail.com"]
-  spec.summary       = %q{Write a short summary. Required.}
-  spec.description   = %q{Write a longer description. Optional.}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.name          = 'yt-core'
+  spec.version       = Yt::Core::VERSION
+  spec.authors       = ['Claudio Baccigalupo']
+  spec.email         = ['claudio@fullscreen.net']
+  spec.description   = %q{Youtube V3 API client.}
+  spec.summary       = %q{Yt makes it easy to interact with Youtube V3 API by
+    providing a modular, intuitive and tested Ruby-style API.}
+  spec.homepage      = 'http://github.com/fullscreen/yt-core'
+  spec.license       = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.required_ruby_version = '>= 2.2.2'
 
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake"
+  spec.files         = `git ls-files -z`.split("\x0").reject do |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 'yt-support', '>= 0.1.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rspec', '~> 3.5'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'coveralls', '~> 0.8.20'
+  spec.add_development_dependency 'pry-nav', '~> 0.2.4'
+  spec.add_development_dependency 'jekyll', '~> 3.4'
+  spec.add_development_dependency 'yard', '~> 0.9.8'
 end