encoding-dot-com 0.0.1

data/lib/encoding_dot_com/queue.rb

@@ -0,0 +1,127 @@
+require 'nokogiri'
+
+module EncodingDotCom
+  # A remote facade to the encoding.com queue.
+  #
+  # The queue is stateless and can be reused for multiple requests.
+  class Queue
+    # Where encoding.com expects messages to be posted to.
+    ENDPOINT = "http://manage.encoding.com/"
+
+    # Creates a new facacde given an encoding.com user id & key, and
+    # an HTTP library implementation.
+    #
+    # +user_id+:: your encoding.com user id
+    # +user_key+:: your encoding.com secret key
+    # +http+:: should respond to post, and return an object responding to
+    #          +#code+ and +#to_s+
+    def initialize(user_id, user_key, http=HttpAdapters::CurbAdapter.new)
+      @user_id, @user_key, @http = user_id, user_key, http
+    end
+
+    # Add a video/image to the encoding.com queue to be encoded in
+    # various formats. Item will be processed after being added.
+    #
+    # +source+:: the source url
+    # +formats+:: a hash of destination urls => format objects
+    def add_and_process(source, formats={})
+      add_request("AddMedia", source, formats)
+    end
+
+    # Add a video/image to the encoding.com queue to be encoded in
+    # various formats.
+    #
+    # +source+:: the source url
+    # +formats+:: a hash of destination urls => format objects
+    def add(source, formats={})
+      add_request("AddMediaBenchmark", source, formats)
+    end
+
+    # Returns the status string of a particular media item in the
+    # encoding.com queue. The status will be for the job as a whole,
+    # rather than individual ouput formats
+    def status(media_id)
+      response = make_request("GetStatus") {|q| q.mediaid media_id }
+      response.xpath("/response/status").text
+    end
+
+    # Returns the full status of an entry in the encoding.com queue,
+    # including details about the status of individual formats
+    def full_status(media_id) #:nodoc:
+      response = make_request("GetStatus") do |q|
+        q.mediaid media_id
+      end
+    end
+    
+    # Returns a list of media in the encoding.com queue
+    def list
+      make_request("GetMediaList").xpath("/response/media").map {|node| MediaListItem.new(node) }
+    end
+
+    # Cancels a media item in the encoding.com queue
+    def cancel(media_id)
+      make_request("CancelMedia") {|q| q.mediaid media_id }
+    end
+
+    # Process an item already in the encoding.com queue
+    def process(media_id)
+      make_request("ProcessMedia") {|q| q.mediaid media_id }
+    end
+    
+    # Replaces all the formats in an item on the encoding.com queue
+    # with the formats provided. This also kicks off the encoding
+    # process - there is no need to call process after this.
+    #
+    # +media_id+:: id of the item in the encoding.com queue
+    # +formats+:: a hash of destination urls => Format objects
+    def update(media_id, formats={})
+      make_request("UpdateMedia") do |q|
+        q.mediaid media_id
+        formats.each {|url, format| format.build_xml(q, url) }        
+      end
+    end
+
+    # Returns a MediaInfo object with some attributes of the video
+    # identified by media_id.
+    def info(media_id)
+      response = make_request("GetMediaInfo") {|q| q.mediaid media_id }
+      MediaInfo.new(response)
+    end
+
+    private
+
+    def add_request(action, source, formats)
+      response = make_request(action) do |q|
+        q.source source
+        formats.each {|url, format| format.build_xml(q, url) }
+      end
+      media_id = response.xpath("/response/MediaID").text
+      media_id.to_i if media_id
+    end
+    
+    def make_request(action_name, &block)
+      query = build_query(action_name, &block)
+      response = @http.post(ENDPOINT, :xml => query)
+      raise AvailabilityError.new unless response.code == "200"
+      xml = Nokogiri::XML(response.body)
+      check_for_response_errors(xml)
+      xml
+    end
+
+    def build_query(action)
+      query = Nokogiri::XML::Builder.new do |q|
+        q.query {
+          q.userid @user_id
+          q.userkey @user_key
+          q.action action
+          yield q if block_given?
+        }
+      end.to_xml
+    end
+    
+    def check_for_response_errors(xml)
+      errors = xml.xpath("/response/errors/error").map {|e| e.text }
+      raise MessageError.new(errors.join(", ")) unless errors.empty?
+    end
+  end
+end

data/lib/encoding_dot_com/thumbnail_format.rb

@@ -0,0 +1,40 @@
+module EncodingDotCom
+  # A Thumbnail output format
+  class ThumbnailFormat < Format #:nodoc:
+    allowed_attributes :output, :time, :width, :height
+
+    # Creates a new ThumbnailFormat. You should be calling
+    # Format.create(attributes) rather than this constructor directly.
+    def initialize(attributes={})
+      @attributes = attributes.merge("output" => "thumbnail")
+      validate_attributes
+    end
+
+    def validate_attributes
+      validate_time
+      validate_height
+      validate_width
+    end
+
+    private
+    
+    def validate_time
+      unless time.nil? || time.to_f > 0.01 || time.to_s =~ /\d\d:[0-5]\d:[0-5]\d(\.\d+)?/
+        raise IllegalFormatAttribute.new("Time must be a number greater than 0.01 or HH:MM:SS.ms, was #{time}")
+      end
+    end
+
+    def validate_height
+      unless height.nil? || height.to_i > 0
+        raise IllegalFormatAttribute.new("Height must be a positive integer, was #{height}")
+      end
+    end
+
+    def validate_width
+      unless width.nil? || width.to_i > 0
+        raise IllegalFormatAttribute.new("Width must be a positive integer, was #{width}")
+      end
+    end
+  end
+end
+  

data/lib/encoding_dot_com/video_format.rb

@@ -0,0 +1,40 @@
+module EncodingDotCom
+  class VideoFormat < Format #:nodoc:
+    ALLOWED_OUTPUT_FORMATS = %w{flv fl9 wmv 3gp mp4 m4v ipod iphone appletv psp zune mp3 wma}.freeze
+    
+    allowed_attributes :output, :size, :bitrate, :framerate, :video_codec, :audio_bitrate, :audio_sample_rate, :audio_codec, :audio_channels_number, :audio_volume, :maxrate, :minrate, :bufsize, :keyframe, :start, :duration, :rc_init_occupancy, :crop_top, :crop_left, :crop_right, :crop_bottom, :logo_source, :logo_x, :logo_y, :logo_mode, :logo_threshold
+    boolean_attributes :two_pass, :cbr, :deinterlacing, :add_meta, :turbo
+    
+    def initialize(attributes={})
+      @attributes = attributes
+      check_valid_output_format
+      mixin_output_attribute_restrictions
+      validate_attributes
+    end
+
+    private
+    
+    def check_valid_output_format
+      unless ALLOWED_OUTPUT_FORMATS.include?(@attributes["output"])
+        raise IllegalFormatAttribute.new("Output format #{@attributes["output"]} is not allowed.")
+      end
+    end
+    
+    def mixin_output_attribute_restrictions
+      module_name = "AttributeRestrictions#{@attributes["output"].capitalize}"
+      restrictions = EncodingDotCom.const_get(module_name)
+      (class << self; self; end).send(:include, restrictions)
+    end
+    
+    def validate_attributes
+      validate_video_codec
+      validate_size
+    end
+
+    def validate_size
+    end
+
+    def validate_video_codec
+    end
+  end
+end

data/lib/encoding_dot_com.rb

@@ -0,0 +1,2 @@
+require 'encoding-dot-com'
+

data/spec/encoding_dot_com/http_adapters/curb_adapter_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "CurbAdapter" do
+  before :each do
+    @http = EncodingDotCom::HttpAdapters::CurbAdapter.new
+    @mock_easy = mock("Curl::Easy mock", :null_object => true)
+    @mock_easy.should_receive(:follow_location=).with(true)    
+    Curl::Easy.should_receive(:new).with("http://example.com").and_yield(@mock_easy).and_return(@mock_easy)    
+  end
+
+  it "should respond to post with a url and hash of post parameters" do
+    @mock_easy.should_receive(:http_post)
+    Curl::PostField.should_receive(:content).with("foo", "bar")
+    
+    @http.post("http://example.com", {:foo => "bar"})
+  end
+
+  it "should raise an AvailabilityError if a Curl exception is raised" do
+    @mock_easy.should_receive(:http_post).and_raise(StandardError.new("Boom!"))
+
+    lambda { @http.post("http://example.com") }.should raise_error(EncodingDotCom::AvailabilityError, "Boom!")
+  end
+
+  it "should return a response with a status code" do
+    @mock_easy.should_receive(:http_post)
+    @mock_easy.should_receive(:response_code).and_return(200)
+    @http.post("http://example.com").code.should == "200"
+  end
+
+  it "should return a response with a body" do
+    @mock_easy.should_receive(:http_post)
+    @mock_easy.should_receive(:body_str).and_return("Hello!")
+    @http.post("http://example.com").body.should == "Hello!"
+  end
+end

data/spec/encoding_dot_com/http_adapters/net_http_adapter_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "NetHttpAdapter" do
+  before :each do
+    @http = EncodingDotCom::HttpAdapters::NetHttpAdapter.new
+    
+  end
+
+  it "should respond to post with a url and hash of post parameters" do
+    Net::HTTP.should_receive(:post_form).with(URI.parse("http://example.com"), {:foo => "bar"})
+    @http.post("http://example.com", {:foo => "bar"})
+  end
+
+  it "should raise an AvailabilityError if an exception is raised" do
+    Net::HTTP.should_receive(:post_form).and_raise(Net::HTTPBadResponse.new("bad!"))
+    lambda { @http.post("http://example.com") }.should raise_error(EncodingDotCom::AvailabilityError, "bad!")
+  end
+
+  it "should raise an AvailabilityError if a timeout error is raised" do
+    Net::HTTP.should_receive(:post_form).and_raise(Timeout::Error.new("bad!"))
+    lambda { @http.post("http://example.com") }.should raise_error(EncodingDotCom::AvailabilityError, "bad!")
+  end
+
+  it "should return a response with a status code" do
+    response = stub(:code => "200", :body => "Hello!")
+    Net::HTTP.should_receive(:post_form).and_return(response)
+
+    @http.post("http://example.com").code.should == "200"
+  end
+
+  it "should return a response with a body" do
+    response = stub(:code => "200", :body => "Hello!")
+    Net::HTTP.should_receive(:post_form).and_return(response)
+
+    @http.post("http://example.com").body.should == "Hello!"
+  end
+end

data/spec/flv_vp6_format_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Encoding.com FLV VP6 Format" do
+
+  it "should have an output attribute of 'thumbnail'" do
+    EncodingDotCom::FLVVP6Format.new.output.should == "flv"
+  end
+  
+  it "should return a ThumbnailFormat if the output is 'thumbnail'" do
+    EncodingDotCom::Format.create("output" => "flv", "video_codec" => "vp6").should be_instance_of(EncodingDotCom::FLVVP6Format)
+  end
+  
+  def format_xml(attributes={})
+    format = EncodingDotCom::FLVVP6Format.new(attributes)
+    Nokogiri::XML::Builder.new {|b| format.build_xml(b, "http://example.com") }.to_xml
+  end
+  
+  it "should produce a format node in the xml output" do
+    format_xml.should have_xpath("/format")
+  end
+  
+  it "should produce an output node in the xml output" do
+    format_xml.should have_xpath("/format/output[text()='flv']")
+  end
+  
+  it "should produce a video_codec node in the xml output" do
+    format_xml.should have_xpath("/format/video_codec[text()='vp6']")
+  end
+  
+  it "should produce a size node in the xml output" do
+    format_xml("size" => "16x16").should have_xpath("/format/size[text()='16x16']")
+  end
+  
+  it "should produce a destination node in the output" do
+    format_xml.should have_xpath("/format/destination[text()='http://example.com']")
+  end
+
+  describe "valid sizes" do
+    it "should have widths and heights in multiples of 16" do
+      lambda { EncodingDotCom::FLVVP6Format.new("size" => "32x32") }.should_not raise_error
+      lambda { EncodingDotCom::FLVVP6Format.new("size" => "33x33") }.should raise_error(EncodingDotCom::IllegalFormatAttribute)
+    end
+  end
+end

data/spec/format_spec.rb

@@ -0,0 +1,167 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Encoding.com video format" do
+
+  describe "#create" do
+    it "should return a video format" do
+      EncodingDotCom::Format.create("output" => "mp4").should be_instance_of(EncodingDotCom::VideoFormat)
+    end
+  end
+  
+  describe "#output" do
+    it "should have a output attribute" do
+      EncodingDotCom::VideoFormat.new("output" => "flv").output.should == "flv"
+    end
+
+    it "should be required" do
+      lambda { EncodingDotCom::VideoFormat.new }.should raise_error(EncodingDotCom::IllegalFormatAttribute)
+    end
+
+    it "should not allow an illegal format" do
+      lambda { EncodingDotCom::VideoFormat.new("output" => "foo") }.should raise_error(EncodingDotCom::IllegalFormatAttribute)
+    end
+
+    %w{flv fl9 wmv 3gp mp4 m4v ipod iphone appletv psp zune mp3 wma}.each do |format|
+      it "should allow #{format} as an output format" do
+        lambda { EncodingDotCom::VideoFormat.new("output" => format) }.should_not raise_error
+      end
+    end
+  end
+
+  describe "specifying the size of the output video" do
+    it "should have a size attribute" do
+      EncodingDotCom::VideoFormat.new("output" => "flv", "size" => "640x480").size.should == "640x480"
+    end
+
+    it "should be nil if neither width nor height are specified" do
+      EncodingDotCom::VideoFormat.new("output" => "flv").size.should be_nil
+    end
+
+    describe "size restrictions" do
+      it "should have a sizes of 320x120 or 320x180 if the output format is zune" do
+        lambda { EncodingDotCom::VideoFormat.new("output" => "zune", "size" => "400x400") }.should raise_error(EncodingDotCom::IllegalFormatAttribute)
+        lambda { EncodingDotCom::VideoFormat.new("output" => "zune", "size" => "320x120") }.should_not raise_error        
+        lambda { EncodingDotCom::VideoFormat.new("output" => "zune", "size" => "320x180") }.should_not raise_error
+      end
+      
+      it "should have sizes 320x240 or 640x480 if the output format is ipod" do
+        lambda { EncodingDotCom::VideoFormat.new("output" => "ipod", "size" => "400x400") }.should raise_error(EncodingDotCom::IllegalFormatAttribute)
+      end
+    end
+  end
+
+  describe "allowed video codecs for output formats" do
+    %w{flv libx264 vp6}.each do |codec|
+      it "can be #{codec} if the output format is FLV" do
+        lambda { EncodingDotCom::VideoFormat.new("output" => "flv", "video_codec" => codec) }.should_not raise_error
+      end
+    end
+
+    it "cannot be any other codec if output if Flv" do
+      lambda { EncodingDotCom::VideoFormat.new("output" => "flv", "video_codec" => "foo") }.should raise_error(EncodingDotCom::IllegalFormatAttribute)
+    end
+
+    %w{mpeg4 libx264}.each do |codec|
+      it "can be #{codec} if the output format is MP4" do
+        lambda { EncodingDotCom::VideoFormat.new("output" => "mp4", "video_codec" => codec) }.should_not raise_error
+      end
+    end
+
+    it "cannot be any other codec if output if MP4" do
+      lambda { EncodingDotCom::VideoFormat.new("output" => "mp4", "video_codec" => "foo") }.should raise_error(EncodingDotCom::IllegalFormatAttribute)
+    end
+  end
+  
+  describe "#build_xml" do
+    it "should create a format node" do
+      format = EncodingDotCom::VideoFormat.new("output" => "flv")
+      Nokogiri::XML::Builder.new do |b|
+        format.build_xml(b)
+      end.to_xml.should have_xpath("/format")
+    end
+
+    it "should create an output node" do
+      format = EncodingDotCom::VideoFormat.new("output" => "flv")
+      Nokogiri::XML::Builder.new do |b|
+        format.build_xml(b)
+      end.to_xml.should have_xpath("/format/output[text()='flv']")
+    end
+
+    it "should not create a size node if size is not specified" do
+      format = EncodingDotCom::VideoFormat.new("output" => "flv")
+      Nokogiri::XML::Builder.new do |b|
+        format.build_xml(b)
+      end.to_xml.should_not have_xpath("/format/size")
+    end
+
+    it "should create a size node" do
+      format = EncodingDotCom::VideoFormat.new("output" => "flv", "size" => "0x480")
+      Nokogiri::XML::Builder.new do |b|
+        format.build_xml(b)
+      end.to_xml.should have_xpath("/format/size[text()='0x480']")
+    end
+
+    it "should create a logo node for logo attributes" do
+      format = EncodingDotCom::VideoFormat.new("output" => "flv", "logo_x" => 30)
+      Nokogiri::XML::Builder.new do |b|
+        format.build_xml(b)
+      end.to_xml.should have_xpath("/format/logo/logo_x[text()='30']")
+    end
+
+    it "should have a destination node with the url passed to build xml" do
+      format = EncodingDotCom::VideoFormat.new("output" => "flv")
+      Nokogiri::XML::Builder.new do |b|
+        format.build_xml(b, "http://example.com")
+      end.to_xml.should have_xpath("/format/destination[text()='http://example.com']")
+    end
+
+    %w{two_pass cbr deinterlacing add_meta turbo}.each do |bool|
+      it "should output boolean attribute #{bool} as yes when true" do
+        format = EncodingDotCom::VideoFormat.new("output" => "flv", bool => true)
+        Nokogiri::XML::Builder.new do |b|
+          format.build_xml(b, "http://example.com")
+        end.to_xml.should have_xpath("/format/#{bool}[text()='yes']")
+      end
+
+      it "should output boolean attribute #{bool} as no when false" do
+        format = EncodingDotCom::VideoFormat.new("output" => "flv", bool => false)
+        Nokogiri::XML::Builder.new do |b|
+          format.build_xml(b, "http://example.com")
+        end.to_xml.should have_xpath("/format/#{bool}[text()='no']")
+      end
+    end
+  end
+  
+  describe "setting allowed attributes on a format" do
+    it "should have an attribute :foo" do
+      class ExampleFormat1 < EncodingDotCom::Format
+        allowed_attributes :foo
+      end
+      ExampleFormat1.allowed_attributes.should == ["foo"]
+    end
+    
+    it "should be able to set allowed attributes cumulatively" do
+      class ExampleFormat2 < EncodingDotCom::Format
+        allowed_attributes :foo
+        allowed_attributes :bar
+      end
+      ExampleFormat2.allowed_attributes.should == ["foo", "bar"]
+    end
+  end
+  
+  describe "setting boolean attributes on a format" do
+    it "should also create an allowed attribute" do
+      class ExampleFormat3 < EncodingDotCom::Format
+        boolean_attributes :foo
+      end
+      ExampleFormat3.allowed_attributes.should == ["foo"]
+    end
+    
+    it "should create a boolean attribute" do
+      class ExampleFormat4 < EncodingDotCom::Format
+        boolean_attributes :foo
+      end
+      ExampleFormat4.boolean_attributes.should == ["foo"]
+    end
+  end
+end

data/spec/media_list_item_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "MediaListItem" do
+  it "should have a nil date for dates returned from encoding.com like 0000-00-00 00:00:00" do
+    node = Nokogiri::XML(<<-END
+        <media>
+          <mediafile>foo.wmv</mediafile>
+          <mediaid>1234</mediaid>
+          <mediastatus>Closed</mediastatus>
+          <createdate>2009-01-01 12:00:01</createdate>
+          <startdate>2009-01-01 12:00:02</startdate>
+          <finishdate>0000-00-00 00:00:00</finishdate>
+        </media>
+        END
+                         )
+    EncodingDotCom::MediaListItem.new(node).finish_date.should be_nil
+  end
+end