tubeclip 0.1.0

data/lib/tubeclip/request/base_search.rb

@@ -0,0 +1,76 @@
+class Tubeclip
+  module Request #:nodoc:
+    class BaseSearch #:nodoc:
+      attr_reader :url
+
+      private
+
+      def base_url
+        "http://gdata.youtube.com/feeds/api/"
+      end
+
+      def set_instance_variables( variables )
+        variables.each do |key, value|
+          name = key.to_s
+          instance_variable_set("@#{name}", value) if respond_to?(name)
+        end
+      end
+
+      def build_query_params(params)
+        qs = params.to_a.map { | k, v | v.nil? ? nil : "#{Tubeclip.esc(k)}=#{Tubeclip.esc(v)}" }.compact.sort.join('&')
+        qs.empty? ? '' : (@dev_key ? "?#{qs}&key=#{@dev_key}" : "?#{qs}")
+      end
+    end
+
+
+    module FieldSearch
+      def default_fields
+        "id,updated,openSearch:totalResults,openSearch:startIndex,openSearch:itemsPerPage"
+      end
+
+      def fields_to_params(fields)
+        return "" unless fields
+
+        fields_param = [default_fields]
+
+        if fields[:recorded]
+          if fields[:recorded].is_a? Range
+            fields_param << "entry[xs:date(yt:recorded) > xs:date('#{formatted_date(fields[:recorded].first)}') and xs:date(yt:recorded) < xs:date('#{formatted_date(fields[:recorded].last)}')]"
+          else
+            fields_param << "entry[xs:date(yt:recorded) = xs:date('#{formatted_date(fields[:recorded])}')]"
+          end
+        end
+
+        if fields[:published]
+          if fields[:published].is_a? Range
+            fields_param << "entry[xs:dateTime(published) > xs:dateTime('#{formatted_date(fields[:published].first)}T00:00:00') and xs:dateTime(published) < xs:dateTime('#{formatted_date(fields[:published].last)}T00:00:00')]"
+          else
+            fields_param << "entry[xs:date(published) = xs:date('#{formatted_date(fields[:published])}')]"
+          end
+        end
+
+        if fields[:view_count]
+          fields_param << "entry[yt:statistics/@viewCount > #{fields[:view_count]}]"
+        end
+        
+        if fields[:entry]
+          fields_param << "entry[#{fields[:entry]}]"
+        end
+
+
+        return "&fields=#{URI.escape(fields_param.join(","))}"
+      end
+
+      #youtube taked dates that look like 'YYYY-MM-DD'
+      def formatted_date(date)
+        return date if date.is_a? String
+        if date.respond_to? :strftime
+          date.strftime("%Y-%m-%d")
+        else
+          ""
+        end
+      end
+    end
+  end
+end
+

data/lib/tubeclip/request/error.rb

@@ -0,0 +1,21 @@
+class Tubeclip
+  class Error < RuntimeError
+    attr_reader :code
+    def initialize(msg, code = 0)
+      super(msg)
+      @code = code
+    end
+  end
+
+  class ResourceNotFoundError < Error
+    def initialize(msg)
+      super(msg, 404)
+    end
+  end
+
+  class UploadError < Error
+  end
+
+  class AuthenticationError < Error
+  end
+end

data/lib/tubeclip/request/remote_file.rb

@@ -0,0 +1,70 @@
+require 'open-uri'
+require 'net/http'
+require 'fiber'
+class Tubeclip
+  module Upload
+
+
+    class RemoteFile
+      def initialize(url, opts)
+        @pos = 0
+        @url = url
+        @uri = URI(@url)
+        
+        @content_length = opts[:content_length]
+
+        @fiber = Fiber.new do |first|
+
+          Net::HTTP.start(@uri.host, @uri.port) do |http|
+            request = Net::HTTP::Get.new @uri.request_uri
+            http.request request do |response|
+              response.read_body do |chunk|
+                @pos += chunk.bytesize
+                Fiber.yield chunk
+              end
+            end
+          end
+        end
+
+      end
+
+      def ping?
+
+      end
+
+      def pos
+        @pos
+      end
+
+      def head
+        @head_result || Net::HTTP.start(@uri.host, @uri.port) do |http|
+          @head_result = http.request(Net::HTTP::Head.new(@uri.request_uri))
+        end
+        @head_result
+      end
+
+      def filename
+        File.basename(@url)
+      end
+
+      def path
+        @url
+      end
+
+      def length
+        @content_length ||= head.content_length
+        return @content_length
+      end
+
+      def read(buf_size = 524288)
+        buf = ""
+        while (buf.bytesize < buf_size.to_i) && @fiber.alive?
+          _chunk = @fiber.resume
+          buf << _chunk if _chunk.is_a? String
+        end
+        buf
+      end
+
+    end
+  end
+end

data/lib/tubeclip/request/standard_search.rb

@@ -0,0 +1,49 @@
+class Tubeclip
+  module Request #:nodoc:
+    class StandardSearch < BaseSearch #:nodoc:
+      attr_reader :max_results                     # max_results
+      attr_reader :order_by                        # orderby, ([relevance], viewCount, published, rating)
+      attr_reader :offset                          # start-index
+      attr_reader :time                            # time
+      attr_reader :region                          # region
+      attr_reader :category                        # category
+
+      TYPES = [ :top_rated, :top_favorites, :most_viewed, :most_popular,
+                :most_recent, :most_discussed, :most_linked, :most_responded,
+                :recently_featured, :watch_on_mobile ]
+
+      def initialize(type, options={})
+        @dev_key = options[:dev_key] if options[:dev_key]
+        if TYPES.include?(type)
+          @max_results, @order_by, @offset, @time = nil
+          set_instance_variables(options)
+          @url = base_url
+          @url << @region << "/" if @region
+          @url << type.to_s
+          @url << "_" << @category if @category
+          @url << build_query_params(to_youtube_params)
+        else
+          raise "Invalid type, must be one of: #{ TYPES.map { |t| t.to_s }.join(", ") }"
+        end
+      end
+
+      private
+
+      def base_url
+        super << "standardfeeds/"
+      end
+
+      def to_youtube_params
+        {
+          'max-results' => @max_results,
+          'orderby' => @order_by,
+          'start-index' => @offset,
+          'time' => @time,
+          'v' => Tubeclip::API_VERSION
+        }
+      end
+    end
+
+  end
+end
+

data/lib/tubeclip/request/user_search.rb

@@ -0,0 +1,47 @@
+class Tubeclip
+  module Request #:nodoc:
+    class UserSearch < BaseSearch #:nodoc:
+      include FieldSearch
+      attr_reader :max_results                     # max_results
+      attr_reader :order_by                        # orderby, ([relevance], viewCount, published, rating)
+      attr_reader :offset                          # start-index
+
+      def initialize(params, options={})
+        @max_results, @order_by, @offset = nil
+        @url = base_url
+        @dev_key = options[:dev_key] if options[:dev_key]
+        if params == :favorites
+          @url << "#{options[:user]}/favorites"
+          set_instance_variables(options)
+        elsif params[:user] && options[:favorites]
+          @url << "#{params[:user]}/favorites"
+          set_instance_variables(params)
+          return
+        elsif params[:user]
+          @url << "#{params[:user]}/uploads"
+          set_instance_variables(params)
+        end
+
+        @url << build_query_params(to_youtube_params)
+        @url << fields_to_params(params.delete(:fields)) if params != :favorites && params[:fields]
+      end
+
+      private
+
+      def base_url
+        super << "users/"
+      end
+
+      def to_youtube_params
+        {
+          'max-results' => @max_results,
+          'orderby' => @order_by,
+          'start-index' => @offset,
+          'v' => Tubeclip::API_VERSION
+        }
+      end
+    end
+
+  end
+end
+

data/lib/tubeclip/request/video_search.rb

@@ -0,0 +1,125 @@
+class Tubeclip
+  module Request #:nodoc:
+    class VideoSearch < BaseSearch #:nodoc:
+      include FieldSearch
+
+      # From here: http://code.google.com/apis/youtube/reference.html#yt_format
+      ONLY_EMBEDDABLE = 5
+
+      attr_reader :max_results                     # max_results
+      attr_reader :order_by                        # orderby, ([relevance], viewCount, published, rating)
+      attr_reader :offset                          # start-index
+      attr_reader :query                           # vq
+      attr_reader :response_format                 # alt, ([atom], rss, json)
+      attr_reader :tags                            # /-/tag1/tag2
+      attr_reader :categories                      # /-/Category1/Category2
+      attr_reader :video_format                    # format (1=mobile devices)
+      attr_reader :safe_search                     # safeSearch (none, [moderate], strict)
+      attr_reader :author
+      attr_reader :lang                            # lt
+      attr_reader :restriction
+      attr_reader :duration
+      attr_reader :time
+      attr_reader :hd
+      attr_reader :caption
+      attr_reader :uploader
+      attr_reader :region
+      attr_reader :paid_content
+      attr_reader :location
+      attr_reader :location_radius
+      
+      
+      def initialize(params={})
+        # Initialize our various member data to avoid warnings and so we'll
+        # automatically fall back to the youtube api defaults
+        @max_results, @order_by,
+        @offset, @query,
+        @response_format, @video_format,
+        @safe_search, @author, @lang,
+        @duration, @time, @hd, @caption,
+        @uploader, @region, @location, @location_radius, @paid_content = nil
+        @url = base_url
+        @dev_key = params[:dev_key] if params[:dev_key]
+
+        # Return a single video (base_url + /T7YazwP8GtY)
+        return @url << "/" << params[:video_id] << "?v=#{Tubeclip::API_VERSION}" if params[:video_id]
+
+        @url << "/-/" if (params[:categories] || params[:tags])
+        @url << categories_to_params(params.delete(:categories)) if params[:categories]
+        @url << tags_to_params(params.delete(:tags)) if params[:tags]
+
+        set_instance_variables(params)
+
+        if( params[ :only_embeddable ] )
+          @video_format = ONLY_EMBEDDABLE
+        end
+
+        @url << build_query_params(to_youtube_params)
+        @url << fields_to_params(params.delete(:fields)) if params[:fields]
+      end
+
+      private
+
+      def base_url
+        super << "videos"
+      end
+
+      def to_youtube_params
+        {
+          'max-results' => @max_results,
+          'orderby' => @order_by,
+          'start-index' => @offset,
+          'v' => Tubeclip::API_VERSION,
+          'q' => @query,
+          'alt' => @response_format,
+          'format' => @video_format,
+          'safeSearch' => @safe_search,
+          'author' => @author,
+          'restriction' => @restriction,
+          'lr' => @lang,
+          'duration' => @duration,
+          'time' => @time,
+          'hd' => @hd,
+          'caption' => @caption,
+          'region' => @region,
+          'location' => @location,
+          'location-radius' => @location_radius,
+          'paid-content' => @paid_content,
+          'uploader' => @uploader
+        }
+      end
+
+
+      # Convert category symbols into strings and build the URL. GData requires categories to be capitalized.
+      # Categories defined like: categories => { :include => [:news], :exclude => [:sports], :either => [..] }
+      # or like: categories => [:news, :sports]
+      def categories_to_params(categories)
+        if categories.respond_to?(:keys) and categories.respond_to?(:[])
+          s = ""
+          s << categories[:either].map { |c| c.to_s.capitalize }.join("%7C") << '/' if categories[:either]
+          s << categories[:include].map { |c| c.to_s.capitalize }.join("/") << '/' if categories[:include]
+          s << ("-" << categories[:exclude].map { |c| c.to_s.capitalize }.join("/-")) << '/' if categories[:exclude]
+          s
+        else
+          categories.map { |c| c.to_s.capitalize }.join("/") << '/'
+        end
+      end
+
+      # Tags defined like: tags => { :include => [:football], :exclude => [:soccer], :either => [:polo, :tennis] }
+      # or tags => [:football, :soccer]
+      def tags_to_params(tags)
+        if tags.respond_to?(:keys) and tags.respond_to?(:[])
+          s = ""
+          s << tags[:either].map { |t| Tubeclip.esc(t.to_s) }.join("%7C") << '/' if tags[:either]
+          s << tags[:include].map { |t| Tubeclip.esc(t.to_s) }.join("/") << '/' if tags[:include]
+          s << ("-" << tags[:exclude].map { |t| Tubeclip.esc(t.to_s) }.join("/-")) << '/' if tags[:exclude]
+          s
+        else
+          tags.map { |t| Tubeclip.esc(t.to_s) }.join("/") << '/'
+        end
+      end
+
+    end
+  end
+end
+