ankoder 0.0.1 → 0.0.2

data/History.txt

@@ -1,3 +1,8 @@
+== 0.0.2 2008-02-25
+
+* 1 major enhancement:
+  * include the plugin lib subfile
+
 == 0.0.1 2008-02-25
 
 * 1 major enhancement:

data/Manifest.txt

@@ -6,7 +6,16 @@ Rakefile
 config/hoe.rb
 config/requirements.rb
 lib/ankoder.rb
+lib/ankoder/account.rb
+lib/ankoder/auth.rb
+lib/ankoder/base.rb
+lib/ankoder/browser.rb
+lib/ankoder/download.rb
+lib/ankoder/ext.rb
+lib/ankoder/job.rb
+lib/ankoder/profile.rb
 lib/ankoder/version.rb
+lib/ankoder/video.rb
 log/debug.log
 script/destroy
 script/generate

data/config/hoe.rb

@@ -28,8 +28,7 @@ Run 'rubyforge setup' to prepare your env for access to Rubyforge
 end
 
 
-REV = nil
-ENV["VERSION"] = "0.0.1"
+REV = nil 
 # UNCOMMENT IF REQUIRED: 
 # REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
 VERS = Ankoder::VERSION::STRING + (REV ? ".#{REV}" : "")

data/lib/ankoder/account.rb

@@ -0,0 +1,32 @@
+module Ankoder
+  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(Ankoder::response(Browser::get(self.path, self.session).body))
+    end
+  end
+end

data/lib/ankoder/auth.rb

@@ -0,0 +1,83 @@
+module Ankoder
+  # Authenticate to the ankoder 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)
+  #    profile = user.profiles.find(:first, :conditions => {:name => "iPod 4:3"})
+  #    user.jobs.create :original_file_id => video.id, :profile_id => profile.id
+  #  end
+  #
+  # All the resources (pluralized) are available within the Auth class:
+  #
+  #  jobs, videos, profiles, downloads, account 
+  #
+	class Auth
+    attr_reader :session
+    @@sessions = {}
+    
+    # Authenticate to the _ankoderapi_session service
+    #
+    # options can be:
+    #
+    # * <tt>:login</tt> _ankoderapi_session username
+    # * <tt>:password</tt> _ankoderapi_session 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/ankoder/base.rb

@@ -0,0 +1,252 @@
+module Ankoder 
+  # You can connect to the _ankoderapi_session service permanently
+  #
+  # You can access all the resources and manipulate the objects like in ActiveRecord
+  #
+  #  v = Video.find(15).update_attributes :name => "My edited title"
+  #  puts v.title
+  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
+      #
+      #     Profile.find(:all, :conditions => {:name => /mobile/i})
+      #     Profile.find(:all, :conditions => {:width => '<320'})
+      #     Job.find(:all, :include => "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 = Ankoder::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(Ankoder::response(Browser::get(path+"/"+arg.to_s, session).body)).include_ankoder_object(options[:include])
+      end
+      
+      public
+        
+      # Create the object
+      #
+      #   Download.create :url => "http://host.com/video.avi"
+      def create(attributes={})
+        new(Ankoder::response(Browser::post(path, attributes, session).body))
+      end
+      
+      # Update the object passing its ID
+      #
+      #   Video.update 15, :name => "my title"
+      def update(id, attributes={})
+        Browser::put(path+"/"+id.to_s, attributes, session)
+      end
+      
+      # Destroy the object passing its ID
+      #
+      #   Profile.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
+    #
+    #   Profile.new :name => "test format", :sample_rate => 24000
+    def initialize(attributes={})
+      @attributes = attributes.underscore_keys!
+      @attributes.type_cast!
+    end
+
+    def include_ankoder_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 :name => "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 = Ankoder::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| 
+    Ankoder.module_eval(%{class #{k.to_s.camelize} < Base; end})
+  end
+end

data/lib/ankoder/browser.rb

@@ -0,0 +1,98 @@
+require "net/http"
+
+module Ankoder
+  # This class is used to request the _ankoderapi_session service.
+  #
+  #   Browser::get '/video', session
+  #   Browser::post '/download', {:url => 'http://host.com/video.avi'}, session
+  #   Browser::put '/video/54000', {:name => 'new title'}, session
+  #   Browser::delete '/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, Ankoder::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" => "_ankoderapi_session=#{session};"}) if session
+        h.merge!({"User-Agent" => "_ankoderapi_session ruby API - #{VERSION::STRING}"})
+      end
+      
+      # Login to _ankoderapi_session 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(/_ankoderapi_session=(.*);/i)[1].to_s
+      end
+      
+      # GET on path
+      def get(path, session=nil)
+        path += ".#{OUT_FORMAT}" 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 => OUT_FORMAT).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 => OUT_FORMAT)
+        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+"."+OUT_FORMAT, 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" => OUT_FORMAT).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/ankoder/download.rb

@@ -0,0 +1,17 @@
+module Ankoder
+  class DownloadFailed < RuntimeError; end
+
+  class Download < Base   
+    # Download file from the given URL
+    #
+    #  Download.create('url' => 'http://host.com/file.avi', :postback_url => 'http://your_own_host.com/postback/download')
+    # 
+    #  the return result would be the Video record that you can save for further checking
+    # 
+    #  if the postback url is included, the download result will send back to your server in JSON format
+    def self.create(attributes={})
+      download = super
+      return download 
+    end
+  end
+end

data/lib/ankoder/ext.rb

@@ -0,0 +1,118 @@
+class String
+  # convert "undercore_string" in "UnderscoreString"
+  #
+  # Method from Rails
+  def camelize
+    self.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+end
+
+module Ankoder
+  module CoreExtension
+    module HashExtension
+      # Replace "-" by "_" in all keys of the hash
+      def underscore_keys!
+        self.keys.each do |k|
+          self[k] = self[k].underscore_keys! if self[k].is_a?(Hash)
+          self[k.to_s.gsub("-", "_")] = self[k]
+          delete(k) if k.to_s =~ /-/
+        end
+        self
+      end
+      
+      # Cast each value of the hash in the right format (integer, float, time, boolean)
+      def type_cast!
+        self.keys.each do |k|
+          self[k] = self[k].type_cast! if self[k].is_a?(Hash)
+          self[k] = self[k].to_i if self[k] =~ /^[0-9]+$/
+          self[k] = self[k].to_f if self[k] =~ /^[0-9]+\.[0-9]+$/
+          self[k] = Time.parse(self[k]) if self[k] =~ /[a-z]+ [a-z]+ [0-9]+ [0-9]{2}:[0-9]{2}:[0-9]{2} [a-z0-9\+]+ [0-9]{4}/i
+          self[k] = true if self[k] == "true"
+          self[k] = false if self[k] == "false"
+          self[k] = nil if self[k] == {}
+        end
+        self
+      end
+      
+      # The hash keys are available by calling the method name "key"
+      #
+      #  h = {"profile_id" => 54, "video_id" => 12}
+      #  h.profile_id
+      #  => 54
+      def method_missing(m, *args)
+        if has_key? m.to_s
+          self[m.to_s]
+        else
+          raise NoMethodError, "undefined method `#{m.to_s}' for #{self.class}"
+        end
+      end
+    end
+
+
+    module ArrayExtension
+      def find_with_options(options={})
+        collection = self
+        if options[:conditions]
+          options[:conditions].each_pair do |k,v|
+            collection = collection.find_with_conditions(k => v)
+          end
+        end
+        collection.limit(options[:limit]).order(options[:order]).include_ankoder_object(options[:include])
+      end
+      
+      
+      # Select Ankoder#Base object containing the conditions
+      #
+      #   Profile.find(:all).find_with_conditions(:name => "aaa")
+      def find_with_conditions(conditions={})
+        return self if conditions.nil? or conditions.empty?
+        res = []
+        self.each do |object|
+          object.attributes.each_pair do |k,v|
+            if conditions[k.to_sym]
+              condition = []
+              if not conditions[k.to_sym].is_a?(Regexp) and conditions[k.to_sym].to_s =~ /([<|>|<=|>=|==]+)[\s]*([0-9]+)$/
+                conditions[k.to_sym].to_s.split(" and ").each do |c|
+                  c.match(/([<|>|<=|>=|==]+)[\s]*([0-9]+)$/)
+                  condition << "#{v} #{$1} #{$2}"
+                end
+                res << object if eval(condition.join(" and "))
+              elsif conditions[k.to_sym].is_a?(Regexp)
+                res << object if v =~ conditions[k.to_sym]
+              else
+                res << object if v == conditions[k.to_sym]
+              end
+            end
+          end
+        end
+        return res
+      end
+
+      def limit(lim=nil)
+        return self if lim.nil?
+        self[0..lim-1]
+      end
+
+      def order(order_str=nil)
+        return self if order_str.nil?
+        field, sort = order_str.match(/([a-z0-9_]+)([\s+]*[ASC|DESC]*)/i).to_a[1..-1]
+        sort = "ASC" if sort.nil? or sort.empty?
+        begin
+          self.sort do |x,y|
+            case sort
+            when /ASC/i then x.send(field) <=> y.send(field)
+            when /DESC/i then y.send(field) <=> x.send(field)
+            end
+          end
+        rescue
+          self
+        end
+      end
+      
+      def include_ankoder_object(inc=nil)
+        return self if inc.nil?
+        self.each {|object| object.include_ankoder_object(inc)}
+      end
+    end
+  end
+end

data/lib/ankoder/job.rb

@@ -0,0 +1,18 @@
+module Ankoder
+  class JobFailed < RuntimeError; end
+  
+  class Job < Base
+    # Encode the given video into the given format
+    #
+    #   Video_ID is the video id that get from Ankoder::Download
+    #   Profile_ID is selected from the list of Ankoder::Profile.find(:all)
+    #
+    #   Job.create(:original_file_id => "Video_ID", :profile_id => "Profile_ID", 
+    #              :postback_url => 'http://your_own_host.com/postback/job')
+    def self.create(attributes={}, &block)
+      job = super
+      return job 
+    end
+    
+  end
+end

data/lib/ankoder/profile.rb

@@ -0,0 +1,9 @@
+module Ankoder
+  # to get the list of the supported profile
+  #
+  # Profile.find(:all)
+  #
+  class Profile < Base
+    
+  end
+end

data/lib/ankoder/version.rb

@@ -2,7 +2,7 @@ module Ankoder #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/ankoder/video.rb

@@ -0,0 +1,13 @@
+require 'hmac'
+require 'hmac-sha1'
+
+module Ankoder
+  # Get a video from Ankoder
+  #
+  # Videos.find(video_id)
+  #
+  class Video < Base
+    
+    
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ankoder
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ""
 authors: 
 - RoRCraft.com
@@ -56,7 +56,16 @@ files:
 - config/hoe.rb
 - config/requirements.rb
 - lib/ankoder.rb
+- lib/ankoder/account.rb
+- lib/ankoder/auth.rb
+- lib/ankoder/base.rb
+- lib/ankoder/browser.rb
+- lib/ankoder/download.rb
+- lib/ankoder/ext.rb
+- lib/ankoder/job.rb
+- lib/ankoder/profile.rb
 - lib/ankoder/version.rb
+- lib/ankoder/video.rb
 - log/debug.log
 - script/destroy
 - script/generate