+ @bot.path and datafile methods
[rbot] / data / rbot / plugins / youtube.rb
1 #-- vim:sw=2:et
2 #++
3 #
4 # :title: YouTube plugin for rbot
5 #
6 # Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
7 #
8 # Copyright:: (C) 2008 Giuseppe Bilotta
9
10
11 class YouTubePlugin < Plugin
12   YOUTUBE_SEARCH = "http://gdata.youtube.com/feeds/api/videos?vq=%{words}&orderby=relevance"
13   YOUTUBE_VIDEO = "http://gdata.youtube.com/feeds/api/videos/%{id}"
14
15   YOUTUBE_VIDEO_URLS = %r{youtube.com/(?:watch\?v=|v/)(.*?)(&.*)?$}
16
17   Config.register Config::IntegerValue.new('youtube.hits',
18     :default => 3,
19     :desc => "Number of hits to return from YouTube searches")
20   Config.register Config::IntegerValue.new('youtube.descs',
21     :default => 3,
22     :desc => "When set to n > 0, the bot will return the description of the first n videos found")
23   Config.register Config::BooleanValue.new('youtube.formats',
24     :default => true,
25     :desc => "Should the bot display alternative URLs (swf, rstp) for YouTube videos?")
26
27   def youtube_filter(s)
28     loc = Utils.check_location(s, /youtube\.com/)
29     return nil unless loc
30     if s[:text].include? '<div id="watch-vid-title">'
31       vid = @bot.filter(:"youtube.video", s)
32       return nil unless vid
33       content = _("Category: %{cat}. Rating: %{rating}. Author: %{author}. Duration: %{duration}. %{views} views, faved %{faves} times. %{desc}") % vid
34       return vid.merge(:content => content)
35     elsif s[:text].include? '<!-- start search results -->'
36       vids = @bot.filter(:"youtube.search", s)[:videos]
37       if !vids.empty?
38         return nil # TODO
39       end
40     end
41     # otherwise, just grab the proper div
42     if defined? Hpricot
43       content = (Hpricot(s[:text])/".watch-video-desc").to_html.ircify_html
44     end
45     # suboptimal, but still better than the default HTML info extractor
46     dm = /<div\s+class="watch-video-desc"[^>]*>/.match(s[:text])
47     content ||= dm ? dm.post_match.ircify_html : '(no description found)'
48     return {:title => s[:text].ircify_html_title, :content => content}
49   end
50
51   def youtube_apivideo_filter(s)
52     # This filter can be used either
53     e = s[:rexml] || REXML::Document.new(s[:text]).elements["entry"]
54     # TODO precomputing mg doesn't work on my REXML, despite what the doc
55     # says?
56     #   mg = e.elements["media:group"]
57     #   :title => mg["media:title"].text
58     # fails because "media:title" is not an Integer. Bah
59     vid = {
60       :formats => [],
61       :author => (e.elements["author/name"].text rescue nil),
62       :title =>  (e.elements["media:group/media:title"].text rescue nil),
63       :desc =>   (e.elements["media:group/media:description"].text rescue nil),
64       :cat => (e.elements["media:group/media:category"].text rescue nil),
65       :seconds => (e.elements["media:group/yt:duration/@seconds"].value.to_i rescue nil),
66       :url => (e.elements["media:group/media:player/@url"].value rescue nil),
67       :rating => (("%s/%s" % [e.elements["gd:rating/@average"].value, e.elements["gd:rating/@max"].value]) rescue nil),
68       :views => (e.elements["yt:statistics/@viewCount"].value rescue nil),
69       :faves => (e.elements["yt:statistics/@favoriteCount"].value rescue nil)
70     }
71     if vid[:desc]
72       vid[:desc].gsub!(/\s+/m, " ")
73     end
74     if secs = vid[:seconds]
75       vid[:duration] = Utils.secs_to_short(secs)
76     else
77       vid[:duration] = _("unknown duration")
78     end
79     e.elements.each("media:group/media:content") { |c|
80       if url = (c.elements["@url"].value rescue nil)
81         type = c.elements["@type"].value rescue nil
82         medium = c.elements["@medium"].value rescue nil
83         expression = c.elements["@expression"].value rescue nil
84         seconds = c.elements["@duration"].value.to_i rescue nil
85         fmt = case num_fmt = (c.elements["@yt:format"].value rescue nil)
86               when "1"
87                 "h263+amr"
88               when "5"
89                 "swf"
90               when "6"
91                 "mp4+aac"
92               when nil
93                 nil
94               else
95                 num_fmt
96               end
97         vid[:formats] << {
98           :url => url, :type => type,
99           :medium => medium, :expression => expression,
100           :seconds => seconds,
101           :numeric_format => num_fmt,
102           :format => fmt
103         }.delete_if { |k, v| v.nil? }
104         if seconds
105           vid[:formats].last[:duration] = Utils.secs_to_short(seconds)
106         else
107           vid[:formats].last[:duration] = _("unknown duration")
108         end
109       end
110     }
111     debug vid
112     return vid
113   end
114
115   def youtube_apisearch_filter(s)
116     vids = []
117     title = nil
118     begin
119       doc = REXML::Document.new(s[:text])
120       title = doc.elements["feed/title"].text
121       doc.elements.each("*/entry") { |e|
122         vids << @bot.filter(:"youtube.apivideo", :rexml => e)
123       }
124       debug vids
125     rescue => e
126       debug e
127     end
128     return {:title => title, :vids => vids}
129   end
130
131   def youtube_search_filter(s)
132     # TODO
133     # hits = s[:hits] || @bot.config['youtube.hits']
134     # scrap the videos
135     return []
136   end
137
138   # Filter a YouTube video URL
139   def youtube_video_filter(s)
140     id = s[:youtube_video_id]
141     if not id
142       url = s.key?(:headers) ? s[:headers]['x-rbot-location'].first : s[:url]
143       debug url
144       id = YOUTUBE_VIDEO_URLS.match(url).captures.first rescue nil
145     end
146     return nil unless id
147
148     debug id
149
150     url = YOUTUBE_VIDEO % {:id => id}
151     resp, xml = @bot.httputil.get_response(url)
152     unless Net::HTTPSuccess === resp
153       debug("error looking for movie %{id} on youtube: %{e}" % {:id => id, :e => xml})
154       return nil
155     end
156     debug xml
157     begin
158       return @bot.filter(:"youtube.apivideo", DataStream.new(xml, s))
159     rescue => e
160       debug e
161       return nil
162     end
163   end
164
165   def initialize
166     super
167     @bot.register_filter(:youtube, :htmlinfo) { |s| youtube_filter(s) }
168     @bot.register_filter(:apisearch, :youtube) { |s| youtube_apisearch_filter(s) }
169     @bot.register_filter(:apivideo, :youtube) { |s| youtube_apivideo_filter(s) }
170     @bot.register_filter(:search, :youtube) { |s| youtube_search_filter(s) }
171     @bot.register_filter(:video, :youtube) { |s| youtube_video_filter(s) }
172   end
173
174   def info(m, params)
175     movie = params[:movie]
176     id = nil
177     if movie =~ /^[A-Za-z0-9]+$/
178       id = movie.dup
179     end
180
181     vid = @bot.filter(:"youtube.video", :url => movie, :youtube_video_id => id)
182     if vid
183       str = _("%{bold}%{title}%{bold} [%{cat}] %{rating} @ %{url} by %{author} (%{duration}). %{views} views, faved %{faves} times. %{desc}") %
184         {:bold => Bold}.merge(vid)
185       if @bot.config['youtube.formats'] and not vid[:formats].empty?
186         str << _("\n -- also available at: ")
187         str << vid[:formats].inject([]) { |list, fmt|
188           list << ("%{url} %{type} %{format} (%{duration} %{expression} %{medium})" % fmt)
189         }.join(', ')
190       end
191       m.reply str
192     else
193       m.reply(_("couldn't retrieve video info") % {:id => id})
194     end
195   end
196
197   def search(m, params)
198     what = params[:words].to_s
199     searchfor = CGI.escape what
200     url = YOUTUBE_SEARCH % {:words => searchfor}
201     resp, xml = @bot.httputil.get_response(url)
202     unless Net::HTTPSuccess === resp
203       m.reply(_("error looking for %{what} on youtube: %{e}") % {:what => what, :e => xml})
204       return
205     end
206     debug "filtering XML"
207     vids = @bot.filter(:"youtube.apisearch", DataStream.new(xml, params))[:vids][0, @bot.config['youtube.hits']]
208     debug vids
209     case vids.length
210     when 0
211       m.reply _("no videos found for %{what}") % {:what => what}
212       return
213     when 1
214       show = "%{title} (%{duration}) [%{desc}] @ %{url}" % vids.first
215       m.reply _("One video found for %{what}: %{show}") % {:what => what, :show => show}
216     else
217       idx = 0
218       shorts = vids.inject([]) { |list, el|
219         idx += 1
220         list << ("#{idx}. %{bold}%{title}%{bold} (%{duration}) @ %{url}" % {:bold => Bold}.merge(el))
221       }.join(" | ")
222       m.reply(_("Videos for %{what}: %{shorts}") % {:what =>what, :shorts => shorts},
223               :split_at => /\s+\|\s+/)
224       if (descs = @bot.config['youtube.descs']) > 0
225         vids[0, descs].each_with_index { |v, i|
226           m.reply("[#{i+1}] %{title} (%{duration}): %{desc}" % v, :overlong => :truncate)
227         }
228       end
229     end
230   end
231
232 end
233
234 plugin = YouTubePlugin.new
235
236 plugin.map "youtube info :movie", :action => 'info', :threaded => true
237 plugin.map "youtube [search] *words", :action => 'search', :threaded => true