heywatch 0.0.1 → 1.0.2

data/Manifest.txt

@@ -1,18 +0,0 @@
-Manifest.txt
-README.txt
-Rakefile
-lib/heywatch.rb
-lib/heywatch/video.rb
-lib/heywatch/version.rb
-lib/heywatch/job.rb
-lib/heywatch/ext.rb
-lib/heywatch/encoded_video.rb
-lib/heywatch/download.rb
-lib/heywatch/discover.rb
-lib/heywatch/browser.rb
-lib/heywatch/base.rb
-lib/heywatch/auth.rb
-lib/heywatch/account.rb
-setup.rb
-test/test_helper.rb
-test/test_heywatch.rb

data/README.txt

@@ -1,163 +0,0 @@
-=Hey!Watch - Video Encoding Web Service
-
-Hey!Watch <http://heywatch.com> provides a simple and robust encoding plateform.
-The service allows developers to access a fast, scalable and inexpensive web 
-service to encode videos easier. The API can be easily integrated 
-in any web or desktop applications.
-
-The documentation of the API can be found at http://wiki.heywatch.com/API_Documentation
-
-
-==Getting started
-
-===Transfer a video, encode it in ipod format and download the encoded video
-
- require 'heywatch'
- include HeyWatch
-
- Base::establish_connection! :login => 'login', :password => 'password'
-
- raw_video = Discover.create(:url => 'http://youtube.com/watch?v=SXcpNZCyQJw', :download => true) do |percent, total_size, received|
-   puts "#{percent}%"
- end
- 
- ipod_format = Format.find_by_name('iPod 4:3')
- encoded_video = Job.create(:video_id => raw_video.id, :format_id => ipod_format.id) do |percent|
-   puts "#{percent}%"
- end
-
- puts "downloading {encoded_video.title}"
- path = encoded_video.download
- puts "video saved in {path}"
-
- 
-===Upload a video from the disk, encode it with FTP auto transfer option
-
- raw_video = Video.create(:file => 'videos/myvideo.avi', :title => 'Funny video') do |percent, total_size, received|
-   puts "#{percent}%"
- end
-
- Job.create :video_id => raw_video.id, :default_format => true, :ftp_directive => 'ftp://login:pass@host.com/heywatch_vids/'
-
-
-===Generate a thumbnail
-
-  v = EncodedVideo.find(5400)
-  v.thumbnail :start => 15, :width => 640, :height => 480    
-
-
-===Update your account
-
-  account = Account.find
-  account.update_attributes :ping_url_after_encode => 'http://yourhost.com/ping/encode'
-
-
-
-==Integration in a rails application
-
-This short HOWTO uses the ping options. So in your HeyWatch account, you must
-configure all the ping URL (except transfer for this example).
-
-Examples:
-
- ping_url_after_encode => http://myhost.com/ping/encode
- ping_url_if_error => http://myhost.com/ping/error
-
-
-===Config
-
-In your config/environment.rb:
-
-  require 'heywatch'
-  HeyWatch::Base::establish_connection! :login => 'login', :password => 'passwd'
-
-
-===Item Model
-
- create_table "items", :force => true do |t|
-   t.column "title",       :string,                          :null => false
-   t.column "description", :text,                            :null => false
-   t.column "created_at",  :datetime
-   t.column "updated_at",  :datetime
-   t.column "status",      :string,   :default => "working"
-   t.column "url",         :string
-   t.column "meta",        :text
-   t.column "user_id",     :integer
- end
-
-In app/models/item.rb:
-
- class Item < ActiveRecord::Base
-   belongs_to :user
-   serialize :meta
-   after_create :convert
-
-   # When HeyWatch send videos to your FTP,
-   # they will be available to this HTTP url.
-   def base_url
-     "http://myhost.com/flv/#{self.id}/"
-   end
-
-   # Transfer the given URL and convert the video from 
-   # this address in format 31 (flv format). When the encode
-   # is done, the video will be sent to the specified FTP
-   # with custom path.
-   #
-   # Note item_id which is a custom field.
-   def convert        
-     HeyWatch::Discover.create(
-       :url              => self.url, 
-       :download         => true, 
-       :item_id          => self.id,
-       :title            => self.title, 
-       :automatic_encode => true,
-       :format_id        => 31,
-       :ftp_directive    => "ftp://login:passwd@myhost.com/flv/#{self.id}/"
-     )
-   end
- end
-
-
-===Ping Controller
-
-In app/controllers/ping_controller.rb:
-
- class PingController < ApplicationController
-   before_filter :find_item
-
-   def encode
-     @encoded_video = HeyWatch::EncodedVideo.find(params[:encoded_video_id])
-     @full_url = @item.base_url + @encoded_video.filename
-     @item.status = 'finished'
-     @item.meta = {
-       :url       => @full_url,
-       :thumb     => @full_url + ".jpg",
-       :size      => @encoded_video.specs["size"],
-       :mime_type => @encoded_video.specs["mime_type"],
-       :length    => @encoded_video.specs.video["length"]
-     }
-     @item.save
-     @encoded_video.job.video.destroy # delete the raw video
-     @encoded_video.destroy # delete the encoded video
-     render :nothing => true
-   end
-
-   def error
-     if params[:discover_id]
-       error_msg = "No video link found"
-     else
-       error_msg = HeyWatch::ErrorCode[params[:error_code].to_i]      
-     end
-     @item.update_attributes :status => 'error'
-     ItemMailer.deliver_error(error_msg, @item.user)
-     render :nothing => true
-   end
-
-   private
-
-   # item_id is a custom_field sent in Item#convert.
-   # Thanks to it, we can track the item.
-   def find_item
-     @item = Item.find params[:item_id]
-   end
- end

data/Rakefile

@@ -1,74 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'rake/contrib/rubyforgepublisher'
-require 'fileutils'
-require 'hoe'
-include FileUtils
-require File.join(File.dirname(__FILE__), 'lib', 'heywatch', 'version')
-
-AUTHOR = 'Bruno Celeste'  # can also be an array of Authors
-EMAIL = "bruno.celeste@heywatch.com"
-DESCRIPTION = "Ruby Library for HeyWatch service (http://heywatch.com)."
-GEM_NAME = 'heywatch' # what ppl will type to install your gem
-RUBYFORGE_PROJECT = 'heywatch' # The unix name for your project
-HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
-
-
-NAME = "heywatch"
-REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
-VERS = ENV['VERSION'] || (HeyWatch::VERSION::STRING + (REV ? ".#{REV}" : ""))
-CLEAN.include ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
-RDOC_OPTS = ['--quiet', '--title', 'heywatch documentation',
-    "--opname", "index.html",
-    "--line-numbers", 
-    "--main", "README.txt",
-    "--inline-source"]
-
-class Hoe
-  def extra_deps 
-    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
-  end 
-end
-
-# Generate all the Rake tasks
-# Run 'rake -T' to see list of generated tasks (from gem root directory)
-hoe = Hoe.new(GEM_NAME, VERS) do |p|
-  p.author = AUTHOR 
-  p.description = DESCRIPTION
-  p.email = EMAIL
-  p.summary = DESCRIPTION
-  p.url = HOMEPATH
-  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
-  p.test_globs = ["test/**/test_*.rb"]
-  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
-  
-  # == Optional
-  p.extra_deps = [ ['xml-simple', '>= 1.0.0'] ]     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
-  p.spec_extras = {:extra_rdoc_files => ["README.txt"], :rdoc_options => RDOC_OPTS}    # A hash of extra values to set in the gemspec.
-end
-
-
-desc 'Generate website files'
-task :website_generate do
-  Dir['website/**/*.txt'].each do |txt|
-    sh %{ ruby scripts/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
-  end
-end
-
-desc 'Upload website files to rubyforge'
-task :website_upload do
-  config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
-  host = "#{config["username"]}@rubyforge.org"
-  remote_dir = "/var/www/gforge-projects/#{RUBYFORGE_PROJECT}/"
-  # remote_dir = "/var/www/gforge-projects/#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
-  local_dir = 'website'
-  sh %{rsync -av #{local_dir}/ #{host}:#{remote_dir}}
-end
-
-desc 'Generate and upload website files'
-task :website => [:website_generate, :website_upload]

data/lib/heywatch/account.rb

@@ -1,32 +0,0 @@
-module HeyWatch
-  class Account < Base #:nodoc:
-    def new_record?
-      false
-    end
-    
-    def update_attributes(attributes={})
-      attributes.delete "account"
-      attributes.keys.each do |k|
-        attributes.merge!("user[#{k.to_s}]" => attributes[k])
-        attributes.delete k
-      end
-
-      if Account.update(id, attributes)
-        reload
-        true
-      end
-    end
-
-    def reload
-      @attributes = Account.find.attributes
-    end
-    
-    def id
-      ""
-    end
-    
-    def self.find(*args)
-      new(HeyWatch::response(Browser::get(self.path, self.session).body))
-    end
-  end
-end

data/lib/heywatch/auth.rb

@@ -1,83 +0,0 @@
-module HeyWatch
-  # Authenticate to the Hey!Watch service
-  #
-  #  user = Auth.create("login", "password")
-  #  user.account
-  #
-  # If you want to recover a session:
-  #
-  #  user = Auth.recover(session_id)
-  #  user.account
-  #
-  # The initialize and create methods can take blocks.
-  #
-  #  Auth.create("login", "password") do |user|
-  #    video = user.videos.find(:first)
-  #    format = user.formats.find(:first, :conditions => {:name => "iPod 4:3"})
-  #    user.jobs.create :video_id => video.id, :format_id => format.id
-  #  end
-  #
-  # All the resources (pluralized) are available within the Auth class:
-  #
-  #  jobs, encoded_videos, videos, formats, downloads, discovers, logs, account
-  #
-	class Auth
-    attr_reader :session
-    @@sessions = {}
-    
-    # Authenticate to the Hey!Watch service
-    #
-    # options can be:
-    #
-    # * <tt>:login</tt> Hey!Watch username
-    # * <tt>:password</tt> Hey!Watch password
-    # * <tt>:session</tt> A previous session, using this option, you will not be reconnected, you will just recover your session
-		def initialize(options={}, &block)
-      if options[:session]
-        @session = options[:session]
-      else
-        @session = Browser::login(options[:login], options[:password])
-        @@sessions.merge!(@session => true)
-      end
-      yield self if block_given?
-		end
-		
-		# Same as initialize
-		#
-    #   Auth::create 'login', 'password'
-    def self.create(login, password, &block)
-      new(:login => login, :password => password, &block)
-    end
-    
-    # Recover a session
-    #
-    #  Auth.recover(session_id)
-    def self.recover(session, &block)
-      #raise SessionNotFound if @@sessions[session].nil?
-      new(:session => session, &block)
-    end
-
-    Resources.each do |k| 
-      Auth.module_eval(%{
-                         def #{k.to_s+"s"}
-                           klass = #{k.to_s.camelize}
-                           klass.session = @session
-                           klass
-                         end
-                        }
-                      )
-    end
-    
-    # Delete the current session
-    def destroy
-      @@sessions.delete(@session)
-      @session = nil
-    end
-    
-    # Show account info
-    def account
-      Account.session = @session
-      Account.find(:first)
-    end
-	end
-end

data/lib/heywatch/base.rb

@@ -1,269 +0,0 @@
-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