heywatch 0.0.1

data/lib/heywatch/base.rb

@@ -0,0 +1,269 @@
+module HeyWatch 
+  # You can connect to the Hey!Watch service permanently
+  #
+  #  Base::establish_connection! :login => "login", :password => "password"
+  #
+  # You can access all the resources and manipulate the objects like in ActiveRecord
+  #
+  #  EncodedVideo.find(:all, :conditions => {:title => /bad video/i}).each do |v|
+  #    v.destroy
+  #  end
+  #
+  #  Format.create :name => "my new format", :video_codec => "mpeg4", ...
+  #  
+  #  f = Format.new
+  #  f.container = "avi"
+  #  f.audio_codec = "mp3"
+  #  ...
+  #  f.save
+  #
+  #  v = Video.find(15).update_attributes :title => "My edited title"
+  #  puts v.title
+  #
+  #  Format.find_by_name("iPod 4:3")
+  #  
+  #  Format.find_all_by_name /ipod/i
+  class Base
+    attr_reader :attributes, :errors
+    
+    class << self
+      def session=(session) #:nodoc:
+        @session = session
+      end
+
+      def session #:nodoc:
+        (@session || Base.session) rescue nil
+      end
+      
+      # Establish the connection for all your session
+      def establish_connection!(options={})
+        Base.session = Browser::login(options[:login], options[:password])
+      end
+
+      def disconnect!
+        Base.session = nil
+      end
+      
+      def method_missing(m, *args) #:nodoc:
+        if m.to_s =~ /find_by_(.*)/
+          find(:first, :conditions => {$1.to_sym => args.first}) rescue nil
+        elsif m.to_s =~ /find_all_by_(.*)/
+          find :all, {:conditions => {$1.to_sym => args.first}}.merge(args[1]||{})
+        else
+          raise NoMethodError, "undefined method `#{m.to_s}' for #{self}"
+        end
+      end
+
+      def path #:nodoc:
+        return @path if @path
+        "/"+self.to_s.split("::").last.
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+      end
+      
+      # if the path of the resource is not standard, you can set it manually.
+      #
+      #   class Log < Base
+      #      self.path = "/user_logs"
+      #   end
+      def path=(path) #:nodoc:
+        @path = path
+      end
+
+      # Find objects
+      # 
+      # Arguments:
+      #
+      # * <tt>ID</tt> ID of the object
+      # * <tt>:first</tt> retrieve the first result
+      # * <tt>:all</tt> retrieve all the results
+      # 
+      # Options:
+      #   
+      # * <tt>:conditions</tt> {:fieldname => "keyword"} or {:fieldname => /[0-9]+/}
+      # * <tt>:order</tt> to sort the result
+      # * <tt>:limit</tt> limit the number of result to return
+      # * <tt>:include</tt> fetch the object to include
+      #
+      #     Format.find(:all, :conditions => {:name => /mobile/i})
+      #     Format.find(:all, :conditions => {:width => '<320'})
+      #     Job.find(:all, :include => "encoded_video", :order => "created_at DESC", :limit => 3)
+      #     Video.find :first
+      #     Download.find(5)
+      def find(*args)
+        scope, options = args     
+        options ||= {}
+        case scope
+          when :all   then find_every(options)
+          when :first then find_every(options).first
+          else             find_single(scope, options)
+        end
+      end
+      
+      private
+      
+      def find_every(options) #:nodoc:
+        collection = []
+        res = HeyWatch::response(Browser::get(path, session).body)
+        return collection if res.empty?
+        
+        [res[res.keys.first]].flatten.each {|object| collection << new(object)}
+        collection.find_with_options(options)
+      end
+      
+      def find_single(arg, options) #:nodoc:
+        new(HeyWatch::response(Browser::get(path+"/"+arg.to_s, session).body)).include_heywatch_object(options[:include])
+      end
+      
+      public
+        
+      # Create the object
+      #
+      #   Download.create :url => "http://host.com/video.avi"
+      def create(attributes={})
+        new(HeyWatch::response(Browser::post(path, attributes, session).body))
+      end
+      
+      # Update the object passing its ID
+      #
+      #   EncodedVideo.update 15, :title => "my title"
+      def update(id, attributes={})
+        Browser::put(path+"/"+id.to_s, attributes, session)
+      end
+      
+      # Destroy the object passing its ID
+      #
+      #   Format.destroy 12
+      def destroy(id)
+        Browser::delete(path+"/"+id.to_s, session)
+      end
+      
+      # Destroy all the objects
+      #
+      #   Video.destroy_all
+      def destroy_all
+        find(:all).each do |object|
+          object.destroy
+        end
+      end
+
+      # Count request
+      #
+      # Accept :conditions like in Base#find
+      def count(field=nil, options={})
+        find(:all, options).size
+      end
+    end
+    
+    # Instanciate a new object
+    #
+    #   Format.new :name => "test format", :sample_rate => 24000
+    def initialize(attributes={})
+      @attributes = attributes.underscore_keys!
+      @attributes.type_cast!
+    end
+
+    def include_heywatch_object(objects=nil) #:nodoc:
+      return self if objects.nil?
+      objects = objects.to_s.split(",") if objects.is_a?(String) or objects.is_a?(Symbol)
+      objects.each do |ob|
+        begin
+          self.instance_variable_set "@#{ob}", (self.send(ob) rescue nil)
+          self.instance_eval "attr_reader #{ob.to_sym}"
+        rescue
+        end
+      end
+      self
+    end
+
+    # Save the object. 
+    #
+    # If the object doesn't exist, it will be created, otherwise updated.
+    # If an error occurred, @errors will be filled. This method doesn't raise.
+    def save
+      begin
+        save!
+        true
+      rescue => e
+        @errors = e.to_s
+        false
+      end
+    end
+    
+    # Save the current object
+    #
+    # Raise if an error occurred. Return self.
+    def save!
+      if new_record?
+        self.class.create(@attributes)
+      else
+        update_attributes(@attributes)
+      end
+      self
+    end
+
+    def id #:nodoc:
+      @attributes["id"].to_i
+    end
+    
+    # Update the object with the given attributes
+    #
+    #   Video.find(10).update_attributes :title => "test title"
+    def update_attributes(attributes={})
+      if self.class.update(id, attributes)
+        reload
+        true
+      end
+    end
+    
+    # Destroy the object
+    #
+    #   Video.find(56).destroy
+    def destroy
+      self.class.destroy(id)
+    end
+    
+    # Reload the current object
+    #
+    #   j = Job.find(5400)
+    #   j.reload
+    def reload
+      unless new_record?
+        @attributes = self.class.find(self.id).attributes
+      end
+      self
+    end
+    
+    def new_record? #:nodoc:
+      @attributes["id"].nil?
+    end
+    
+    def method_missing(m, *args) #:nodoc:
+      method_name = m.to_s
+      case method_name[-1..-1]
+      when '='
+        @attributes[method_name[0..-2]] = *args.first
+      when '?'
+        @attributes[method_name[0..-2]]
+      else
+        if instance_variables.include?("@#{m.to_s}")
+          eval("@#{m.to_s}")
+        else
+          if object_id = @attributes[m.to_s+"_id"] # belongs_to
+            klass = HeyWatch::const_get(m.to_s.camelize)
+            klass.session = self.class.session
+            klass.find(object_id)
+          else
+            @attributes[m.to_s] rescue nil
+          end
+        end
+      end
+    end
+  end
+
+  Resources.each do |k| 
+    HeyWatch.module_eval(%{class #{k.to_s.camelize} < Base; end})
+  end
+end

data/lib/heywatch/browser.rb

@@ -0,0 +1,98 @@
+require "net/http"
+
+module HeyWatch
+  # This class is used to request the Hey!Watch service.
+  #
+  #   Browser::get '/video', session
+  #   Browser::post '/download', {:url => 'http://host.com/video.avi'}, session
+  #   Browser::put '/encoded_video/54000', {:title => 'new title'}, session
+  #   Browser::delete '/encoded_video/54000', session
+  class Browser
+    class << self
+      # Raise when code response != 2xx
+      def raise_if_response_error(res)
+        code = res.response.code.to_i
+        message = res.response.message
+        return if code.to_s =~ /^2/
+        
+        raise RequestError, HeyWatch::response(res.body).content if code == 400
+        raise NotAuthorized, message if code == 401
+        raise ResourceNotFound, message if code == 404
+        raise ServerError, message if code == 500
+      end
+
+      def header(session=nil) #:nodoc:
+        h = {}
+        h.merge!({"Cookie" => "_session_id=#{session};"}) if session
+        h.merge!({"User-Agent" => "Hey!Watch ruby API - #{VERSION::STRING}"})
+      end
+      
+      # Login to Hey!Watch service. Return the session ID.
+      #
+      # You should not use it directly, use Auth#create instead
+      #
+      #  Browser::login 'login', 'password'
+      def login(login, password) #:nodoc:
+        res = Browser::post("/auth/login", :login => login, :password => password)
+        return res["Set-cookie"].match(/_session_id=(.*);/i)[1].to_s
+      end
+      
+      # GET on path
+      def get(path, session=nil)
+        path += ".#{OutFormat}" unless path.include? "."
+        res = Net::HTTP.start(Host) {|http| http.get(path, header(session))}
+        raise_if_response_error(res)
+        res
+      end
+
+      # POST on path and pass the query(Hash)
+      def post(path, query={}, session=nil)
+        res = Net::HTTP.start(Host) {|http| http.post(path, query.merge(:format => OutFormat).to_a.map{|x| x.join("=")}.join("&"), self.header(session))}
+        raise_if_response_error(res)
+        res
+      end
+      
+      # PUT on path and pass the query(Hash)
+      def put(path, query={}, session=nil)
+        req = Net::HTTP::Put.new(path, header(session))
+        req.form_data = query.merge(:format => OutFormat)
+        res = Net::HTTP.new(Host).start {|http| http.request(req) }
+        raise_if_response_error(res)
+        true
+      end
+      
+      # DELETE on path
+      def delete(path, session=nil)
+        res = Net::HTTP.start(Host) {|http| http.delete(path+"."+OutFormat, header(session))}
+        raise_if_response_error(res)
+        true
+      end
+      
+      def post_multipart(path, attributes={}, session=nil) #:nodoc:
+        file = attributes.delete(:file)
+        params = [file_to_multipart("data", File.basename(file),"application/octet-stream", File.read(file))]
+        attributes.merge("format" => OutFormat).each_pair{|k,v| params << text_to_multipart(k.to_s, v.to_s)}
+
+        boundary = '349832898984244898448024464570528145'
+        query = params.collect {|p| '--' + boundary + "\r\n" + p}.join('') + "--" + boundary + "--\r\n"
+        res = Net::HTTP.start(Host) {|http| http.post(path, query, header(session).merge("Content-Type" => "multipart/form-data; boundary=" + boundary))}
+        raise_if_response_error(res)
+        res
+      end
+
+      def text_to_multipart(key,value) #:nodoc:
+        return "Content-Disposition: form-data; name=\"#{CGI::escape(key.to_s)}\"\r\n" + 
+               "\r\n" + 
+               "#{value}\r\n"
+      end
+
+      def file_to_multipart(key,filename,mime_type,content) #:nodoc:
+        return "Content-Disposition: form-data; name=\"#{CGI::escape(key.to_s)}\"; filename=\"#{filename}\"\r\n" +
+               "Content-Transfer-Encoding: binary\r\n" +
+               "Content-Type: #{mime_type}\r\n" + 
+               "\r\n" + 
+               "#{content}\r\n"
+      end
+    end
+  end
+end

data/lib/heywatch/discover.rb

@@ -0,0 +1,39 @@
+module HeyWatch
+  class VideoNotFound < RuntimeError; end
+  class MultipleVideoFound < RuntimeError; end
+
+  class Discover < Base   
+    # Discover video from the given URL
+    #
+    # If you pass a block, you will follow the process until you get the raw video.
+    # Return the new video if pass a block.
+    #
+    # If more than 1 video is found, raise an exception.
+    #
+    #   Discover.create(:url => 'http://host.com/', :download => true) {|percent, total_size, received| ...}
+    def self.create(attributes={}, &block)
+      discover = super
+      return discover unless attributes[:download] and block_given?
+      
+      while (discover.status rescue "working") == "working"
+        discover.reload rescue nil
+      end
+
+      case discover.status
+      when "ok"
+        if discover.results.result.is_a?(String)
+          while discover.download_id.nil?
+            sleep 1
+            discover.reload
+          end
+          video = Download.progress(discover.download, &block)
+          return video
+        else
+          raise MultipleVideoFound, "You have to choose the video you want to transfer"
+        end
+      when "error"
+        raise VideoNotFound, "No video found in this website"
+      end
+    end
+  end
+end

data/lib/heywatch/download.rb

@@ -0,0 +1,30 @@
+module HeyWatch
+  class DownloadFailed < RuntimeError; end
+
+  class Download < Base   
+    # Download file from the given URL
+    #
+    # If you pass a block, you get the progress. Return the new video.
+    #
+    #   Download.create(:url => 'http://host.com/file.avi') {|percent, total_size, received| ...}
+    def self.create(attributes={}, &block)
+      download = super
+      return download unless block_given?
+      self.progress(download, &block)
+    end
+
+    def self.progress(download, &block)
+      while download.status == "downloading"
+        download.reload
+        yield download.progress.percent, download.length, download.progress.current_length
+        sleep 1
+      end
+      case download.status
+      when "finished"
+        return download.video
+      when "error"
+        raise DownloadFailed, download.error_msg
+      end
+    end
+  end
+end

data/lib/heywatch/encoded_video.rb

@@ -0,0 +1,49 @@
+module HeyWatch
+  class EncodedVideo < Base
+    def url
+      res = Browser::get("#{self.class.path}/#{self.id}.bin", self.class.session)
+      HeyWatch::sanitize_url(res.get_fields("Location").first)
+    end
+    
+    # Generate a thumbnail of the encoded video
+    #
+    # options:
+    # * <tt>start:</tt> offset in second
+    # * <tt>width</tt>
+    # * <tt>height</tt>
+    #
+    # All these options are optionals. Return binary data.
+    #
+    #  EncodedVideo.find(:first).thumbnail :start => 15, :width => 320, :height => 240
+    def thumbnail(options={})
+      param = options.to_a.map{|v| v.join("=")}.join("&")
+      res = Browser::get("#{self.class.path}/#{self.id}.jpg#{'?'+param unless param.empty?}", self.class.session)
+      case res
+      when Net::HTTPRedirection
+        Net::HTTP.get_response(URI(HeyWatch::sanitize_url(res["location"]))).body
+      else
+        res.body
+      end
+    end
+    
+    # Download the encoded video
+    #
+    # The path is . by default. You can pass a block to have progression. Return the full path of the video.
+    #
+    #   EncodedVideo.find(:first).download('/tmp') {|progress| puts progress.to_s + '%'}
+    def download(path=".")
+      uri = URI(url)
+      size = self.specs["size"] * 1024
+      path = File.join(path, self.filename)
+      file = File.open(path, "wb")
+      Net::HTTP.start(uri.host) do |http| 
+        http.get(uri.path) do |data|
+          file.write data
+          yield((File.size(path) / size.to_f) * 100) if block_given?
+        end
+      end
+      file.close
+      return path
+    end
+  end
+end