uencode 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rake_tasks~

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in uencode.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :notification => true do
+  watch(%r{^spec/.+_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/README.md

@@ -0,0 +1,60 @@
+# UEncode
+
+A simple Ruby gem to consume the [uEncode](http://www.uencode.com) API.
+
+## Synopsis
+
+``` ruby
+require 'uencode'
+
+# In Rails you can put this inside an initializer
+UEncode.configure do |c|
+  c.customer_key = "your_uencode_api_key"
+end
+
+job = UEncode::Job.new :source => "http://your_source_video_url/foo.avi", :userdata => "This is a simple test"
+
+job.configure_video_output { |c| c.destination = "http://your_destination_url/transcoded.mp4"; c.container = "mpeg4" }
+
+video = UEncode::Medium.new
+
+video.configure_video { |c| c.bitrate = 300000; c.codec = "h264"}
+
+video.configure_audio do |c| 
+  c.bitrate    = 64000
+  c.codec      = "aac"
+  c.samplerate = 44100
+  c.channels   = 1
+end
+
+job << video
+
+capture = UEncode::CaptureOutput.new :destination => "http://whatever.com/foo.zip", :rate => "every 30s"
+job.add_capture capture
+
+request = UEncode::Request.new job
+puts job.to_xml
+response = request.send
+
+puts response.code # => 'Ok'
+puts response.message # => 'Your job was created successfully'
+puts response.jobid # => 1234567
+puts response.userdata # => 'This is a simple test'
+```
+
+## Accepted parameters
+
+Currently all the uEncode API parameters are supported (or so I think :)
+
+Currently the gem does not validate parameters' values, so pay attention at the API docs.
+
+You can see the whole list of accepted parameters in the [uEncode API documentation](http://www.uencode.com/api/300#response_codes).
+
+For the UEncode classes that map to each complex API parameters (like Crop, Size, FrameRate, etc) take a look at the spec file at /spec/elements_spec.rb or read the docs.
+
+## Running the specs
+
+* bundle install
+* rspec spec
+
+

data/Rakefile

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/uencode.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'singleton'
+require 'nokogiri'
+require 'httparty'
+
+module UEncode
+  class << self
+    attr_accessor :customer_key
+
+    def configure
+      yield self
+    end
+  end
+
+  module AttrSetting
+    def set_attributes(options)
+      self.class.const_get("ATTRIBUTES").each { |attr| instance_variable_set(:"@#{attr}", options[attr]) }
+    end
+
+    def initialize(options)
+      set_attributes options
+    end
+
+    def self.included(klass)
+      attr = klass.const_get "ATTRIBUTES"
+      klass.send(:attr_reader, *attr)
+    end
+  end
+end
+
+require "uencode/elements"
+require "uencode/request"
+require "uencode/response"

data/lib/uencode/elements.rb

@@ -0,0 +1,233 @@
+module UEncode
+  class Crop
+    ATTRIBUTES = [:width, :height, :x, :y]
+
+    def to_xml
+      %Q{
+        <crop>
+          <width>#{width}</width>
+          <height>#{height}</height>
+          <x>#{x}</x>
+          <y>#{y}</y>
+        </crop>
+      }
+    end
+  end
+
+  class Size
+    ATTRIBUTES = [:width, :height]
+
+    def to_xml
+      %Q{
+        <size>
+          <width>#{width}</width>
+          <height>#{height}</heignt>
+        </size>
+      }
+    end
+  end
+
+  module RateElement
+    def to_xml
+      %Q{
+        <#{root_name}>
+          <numerator>#{numerator}</numerator>
+          <denominator>#{denominator}</denominator>
+        </#{root_name}>
+      }
+    end
+  end
+
+  class FrameRate
+    include RateElement
+    ATTRIBUTES = [:numerator, :denominator]
+
+    private
+    def root_name; "framerate"; end
+  end
+
+  class Par < FrameRate
+    include RateElement
+    ATTRIBUTES = [:numerator, :denominator]
+
+    private
+    def root_name; "par"; end
+  end
+
+  class CaptureOutput
+    ATTRIBUTES = [:destination, :rate, :stretch, :crop, :size]
+
+    def initialize(options)
+      super
+      @stretch = false if @stretch.nil?
+    end
+
+    def to_xml
+      %Q{
+        <output>
+          <capture>
+            <rate>#{rate}</rate>
+            <destination>#{destination}</destination>
+          #{@crop ? @crop.to_xml : ""}
+          #{@size ? @size.to_xml : ""}
+          </capture>
+        <//output>
+      }
+    end
+  end
+
+  class VideoOutput
+    ATTRIBUTES = [:destination, :container]
+
+    include Enumerable
+
+    # a list of Medium
+    attr_reader :items
+    attr_writer :destination, :container
+
+    def initialize(options)
+      @items = []
+      super
+    end
+
+    def each
+      @items.each { |item|  yield item }
+    end
+
+    def to_xml
+      %Q{
+        <output>
+          <video>
+            <destination>#{destination}</destination>
+            <container>#{container}</container>
+            <media>
+              #{@items.inject("") { |s, item| s << item.to_xml }}
+            </media>
+          </video>
+        </output>
+      }
+    end
+  end
+
+  # Medium is a single video to transcode
+  class Medium
+    def initialize
+      @video_config = VideoConfig.new
+      @audio_config = AudioConfig.new
+    end
+
+    def configure_video
+      yield @video_config
+    end
+
+    def configure_audio
+      yield @audio_config
+    end     
+
+    def video
+      @video_config
+    end
+
+    def audio
+      @audio_config
+    end
+
+    def to_xml
+      %Q{
+        <medium>
+          <video>
+            <bitrate>#{video.bitrate}</birate>
+            <codec>#{video.codec}</birate>
+            #{!video.cbr.nil? ? '<cbr>' + video.cbr.to_s + '</cbr>' : ""}
+            #{video.crop ? video.crop.to_xml : ""}
+            #{video.deinterlace.nil? ? "" : '<deinterlace>' + video.deinterlace.to_s + '</deinterlace>'}
+            #{video.framerate ? video.framerate.to_xml : ""}
+            #{video.height.nil? ? "" : '<height>' + video.height.to_s + '</height>'}
+            #{video.keyframe_interval.nil? ? "" : '<keyframe_interval>' + video.keyframe_interval.to_s + '</keyframe_interval>'}
+            #{video.maxbitrate.nil? ? "" : '<maxbitrate>' + video.maxbitrate.to_s + '</maxbitrate>'}
+            #{video.par ? video.par.to_xml : ""}
+            #{video.profile.nil? ? "" : '<profile>' + video.profile + '</profile>'}
+            #{video.passes.nil? ? "" : '<passes>' + video.passes.to_s + '</passes>'}
+            #{[nil, false].include?(video.stretch) ? "" : '<stretch>' + video.stretch.to_s + '</stretch>'}
+            #{video.width.nil? ? "" : '<width>' + video.width.to_s + '</width>'}
+          </video>
+          <audio>
+            #{audio.codec.nil? ? "" : '<codec>' + audio.codec + '</codec>'}
+            #{audio.bitrate.nil? ? "" : '<bitrate>' + audio.bitrate.to_s + '</bitrate>'}
+            #{audio.channels.nil? ? "" : '<channels>' + audio.channels.to_s + '</channels>'}
+            #{audio.samplerate.nil? ? "" : '<samplerate>' + audio.samplerate.to_s + '</samplerate>'}
+          </audio>
+        </medium>
+      }
+    end
+  end
+
+  # The video configs for each Medium
+  class VideoConfig
+    attr_accessor :bitrate, :codec, :cbr, :crop, :deinterlace, :framerate, :height, :keyframe_interval,
+      :maxbitrate, :par, :profile, :passes, :stretch, :width
+
+    def initialize
+      @cbr         = false
+      @deinterlace = false
+      @profile     = "main"
+      @passes      = 1
+      @stretch     = false
+    end
+  end
+
+  # The audio configs for each Medium
+  class AudioConfig
+    attr_accessor :codec, :bitrate, :channels, :samplerate
+  end
+
+  class Job
+    ATTRIBUTES = [:source, :userdata, :notify]
+
+    include Enumerable
+
+    def initialize(options)
+      @video_output = VideoOutput.new options[:video_output] || {}
+      @captures = []
+      super
+    end
+
+    def configure_video_output
+      yield @video_output      
+    end
+
+    def items
+      @video_output.items
+    end
+
+    def <<(item)
+      @video_output.items << item
+    end
+
+    def add_capture(capture)
+      @captures << capture
+    end
+
+    def each(&block)
+      @video_output.each &block
+    end
+
+    def to_xml
+      xml = %Q{
+        <job>
+          <customerkey>#{UEncode.customer_key}</customerkey>
+          <source>#{source}</source>
+          #{userdata.nil? ? "" : '<userdata>' + userdata + '</userdata>'}
+          #{notify.nil? ? "" : '<notify>' + notify + '</notify>'}
+          <outputs>
+            #{@video_output.to_xml}
+            #{@captures.inject("") { |s, cap| s << cap.to_xml }}
+          </outputs>
+        </job>
+      }
+      Nokogiri::XML(xml).to_xml
+    end
+  end
+
+  [Size, FrameRate, Crop, VideoOutput, CaptureOutput, Job].each { |klass| klass.send :include, AttrSetting }
+end

data/lib/uencode/request.rb

@@ -0,0 +1,33 @@
+module UEncode
+  class Request
+    include HTTParty
+
+    base_uri "https://www.uencode.com"
+    format :xml
+    
+    def initialize(job)
+      @job = job
+    end
+
+    def send
+      response = self.class.put "/jobs?version=300", :body => @job.to_xml
+      parse_response response
+    end
+
+    private
+    def parse_response(response_xml)
+      doc      = Nokogiri::XML response_xml.body
+      code     = doc.xpath("//code").text
+      message  = doc.xpath("//message").text
+      jobid    = doc.xpath("//jobid").text
+      userdata = doc.xpath("//userdata").text
+
+      Response.new(
+        :code     => code,
+        :message  => message,
+        :jobid    => jobid,
+        :userdata => userdata
+      )
+    end
+  end
+end

data/lib/uencode/response.rb

@@ -0,0 +1,30 @@
+module UEncode
+  class Response
+    class BadRequestError < StandardError; end
+    class InvalidKeyError < StandardError; end
+    class NotActiveError  < StandardError; end
+    class ServerError     < StandardError; end
+    class UnknownError    < StandardError; end
+
+    ATTRIBUTES = [:code, :message, :jobid, :userdata]
+
+    include AttrSetting    
+
+    def initialize(options)
+      check_response_code options[:code], options[:message]
+      super
+    end
+
+    private
+    def check_response_code(code, message)
+      return if code == 'Ok'
+      case code
+      when 'BadRequest'; raise BadRequestError, message
+      when 'InvalidKey'; raise InvalidKeyError, message
+      when 'NotActive'; raise NotActiveError, message
+      when 'ServerError'; raise ServerError, message
+      else raise UnknownError, "#{code}: #{message}"
+      end
+    end
+  end
+end

data/lib/uencode/version.rb

@@ -0,0 +1,3 @@
+module UEncode
+  VERSION = "0.0.1"
+end

data/spec/elements_spec.rb

@@ -0,0 +1,478 @@
+require 'spec_helper'
+
+describe UEncode::Medium do
+  let(:medium) { UEncode::Medium.new }
+
+  before :each do
+    medium.configure_video do |c|
+      c.bitrate           = 10000
+      c.codec             = "mp4"
+      c.cbr               = false
+      c.crop              = nil
+      c.deinterlace       = true
+      c.framerate         = UEncode::FrameRate.new :numerator => 1000, :denominator => 1001
+      c.height            = 500
+      c.keyframe_interval = 0
+      c.maxbitrate        = 10000
+      c.par               = nil
+      c.profile           = "baseline"
+      c.passes            = 1
+      c.stretch           = false
+      c.width             = 400
+    end
+
+    medium.configure_audio do |c|
+      c.codec      = "aac"
+      c.bitrate    = 15000
+      c.channels   = 2
+      c.samplerate = 10000
+    end
+  end
+
+  describe "#configure_video" do
+    let(:medium) { UEncode::Medium.new }
+
+    it { medium.video.bitrate.should == 10000 }
+    it { medium.video.codec.should == "mp4" }
+    it { medium.video.cbr.should == false }
+    it { medium.video.crop.should be_nil }
+    it { medium.video.deinterlace.should == true }
+    it { medium.video.framerate.numerator.should == 1000 }
+    it { medium.video.height.should == 500 }
+    it { medium.video.keyframe_interval.should == 0 }
+    it { medium.video.maxbitrate.should == 10000 }
+    it { medium.video.par.should be_nil }
+    it { medium.video.profile.should == "baseline" }
+    it { medium.video.passes.should == 1 }
+    it { medium.video.stretch.should == false }
+    it { medium.video.width.should == 400 }
+  end
+
+  describe "#configure_audio" do
+    let(:medium) { UEncode::Medium.new }
+
+    it { medium.audio.codec.should == "aac" }
+    it { medium.audio.bitrate.should == 15000 }
+    it { medium.audio.channels.should == 2 }
+    it { medium.audio.samplerate.should == 10000 }
+  end
+
+  context "video config default values" do
+    let(:medium_without_configuration) { described_class.new }
+
+    it { medium_without_configuration.video.cbr.should == false }
+    it { medium_without_configuration.video.deinterlace.should == false }
+    it { medium_without_configuration.video.profile.should == "main" }
+    it { medium_without_configuration.video.passes.should == 1 }
+    it { medium_without_configuration.video.stretch.should == false }
+  end
+
+  describe "#to_xml" do
+    let(:xml) { Nokogiri::XML medium.to_xml }
+
+    before :each do
+      medium.configure_video do |c|
+        c.crop = UEncode::Crop.new :width => 125, :height => 150, :x => 100, :y => 200
+        c.par = UEncode::Par.new :numerator => 10, :denominator => 11
+      end
+    end
+
+    it "has a root element named 'media'" do
+      xml.root.name.should == 'medium'
+    end
+
+    it "has the correct video configs" do
+      config = xml.xpath("//video")
+      config.xpath("//video/bitrate").text.should == "10000"
+      config.xpath("//video/codec").text.should == "mp4"
+      config.xpath("//cbr").text.should == "false"
+      config.xpath("//crop/width").text.should == "125"
+      config.xpath("//crop/height").text.should == "150"
+      config.xpath("//crop/x").text.should == "100"
+      config.xpath("//crop/y").text.should == "200"
+      config.xpath("//deinterlace").text.should == "true"
+      config.xpath("//framerate/numerator").text.should == "1000"
+      config.xpath("//framerate/denominator").text.should == "1001"
+      config.xpath("//video/height").text.should == "500"
+      config.xpath("//keyframe_interval").text.should == "0"
+      config.xpath("//maxbitrate").text.should == "10000"
+      config.xpath("//par/numerator").text.should == "10"
+      config.xpath("//par/denominator").text.should == "11"
+      config.xpath("//profile").text.should == "baseline"
+      config.xpath("//passes").text.should == "1"
+      config.xpath("//video/width").text.should == "400"
+    end
+
+    it "does not include the cbr video config when it's null" do
+      medium.configure_video { |c| c.cbr = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/cbr").should be_empty
+    end
+
+    it "does not include the crop video config when it's null" do
+      medium.configure_video { |c| c.crop = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/crop").should be_empty
+    end
+
+    it "does not include the deinterlace video config when it's null" do
+      medium.configure_video { |c| c.deinterlace = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/deinterlace").should be_empty
+    end
+
+    it "does not include the framerate video config when it's null" do
+      medium.configure_video { |c| c.framerate = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/framerate").should be_empty
+    end
+
+    it "does not include the height video config when it's null" do
+      medium.configure_video { |c| c.height = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/height").should be_empty
+    end
+
+    it "does not include the keyframe_interval video config when it's null" do
+      medium.configure_video { |c| c.keyframe_interval = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/keyframe_interval").should be_empty
+    end
+
+    it "does not include the maxbitrate video config when it's null" do
+      medium.configure_video { |c| c.maxbitrate = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/maxbitrate").should be_empty
+    end
+
+    it "does not include the par video config when it's null" do
+      medium.configure_video { |c| c.par = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/par").should be_empty
+    end
+
+    it "does not include the profile video config when it's null" do
+      medium.configure_video { |c| c.profile = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/profile").should be_empty
+    end
+
+    it "does not include the passes video config when it's null" do
+      medium.configure_video { |c| c.passes = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/passes").should be_empty
+    end
+    
+    it "does not include the stretch video config when it's null" do
+      medium.configure_video { |c| c.stretch = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/stretch").should be_empty
+    end
+
+    it "does not include the width video config when it's null" do
+      medium.configure_video { |c| c.width = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//video/width").should be_empty
+    end
+
+    it "does not include the stretch video config when it's false" do
+      medium.configure_video { |c|  c.stretch = false }
+      Nokogiri::XML(medium.to_xml) .xpath("//video/stretch").should be_empty
+    end
+
+    it "has the correct audio configs" do
+      xml.xpath("//audio/codec").text.should == "aac"
+      xml.xpath("//audio/bitrate").text.should == "15000"
+      xml.xpath("//audio/channels").text.should == "2"
+      xml.xpath("//audio/samplerate").text.should == "10000"
+    end
+
+    it "does not include the bitrate audio config when it's null" do
+      medium.configure_audio { |c| c.bitrate = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//audio/bitrate").should be_empty
+    end
+
+    it "does not include the channels audio config when it's null" do
+      medium.configure_audio { |c| c.channels = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//audio/channels").should be_empty
+    end
+
+    it "does not include the samplerate audio config when it's null" do
+      medium.configure_audio { |c| c.samplerate = nil }
+      Nokogiri::XML(medium.to_xml).xpath("//audio/samplerate").should be_empty
+    end
+  end
+end
+
+describe UEncode::VideoOutput do
+  subject { described_class.new :destination => "http://foobar.com/bla.avi", :container => "mpeg4" }
+
+  its(:destination) { should == "http://foobar.com/bla.avi" }
+  its(:container) { should == "mpeg4" }
+
+
+  describe "#to_xml" do
+    let(:video_output) { described_class.new :destination => "http://foo.com/bar.mp4", :container => "mpeg4" }
+    let(:xml) { Nokogiri::XML video_output.to_xml }
+
+
+    it "has a root element named 'output'" do
+      xml.root.name.should == 'output'
+    end
+
+    it "has the correct destination value" do
+      xml.xpath("//output/video/destination").text.should == "http://foo.com/bar.mp4"
+    end
+
+    it "has the correct container value" do
+      xml.xpath("//output/video/container").text.should == "mpeg4"
+    end
+  end
+end
+
+describe UEncode::CaptureOutput do
+  subject { described_class.new({
+    :destination => "http://whatever.com/foo.jpg",
+    :rate => "at 20s",
+    :stretch => false
+  }) }
+
+  its(:destination) { should == "http://whatever.com/foo.jpg" }
+  its(:rate) { should == "at 20s" }
+  its(:stretch) { should == false }
+
+  context "default values" do
+    let(:capture) { described_class.new :rate => "every 10s" }
+
+    it { capture.stretch.should == false }
+  end
+
+  describe "#to_xml" do
+    let(:crop) { UEncode::Crop.new :width => 125, :height => 140, :x => 100, :y => 200 }
+    let(:size) { UEncode::Size.new :width => 400, :height => 500 }
+     let(:xml) {
+       Nokogiri::XML described_class.new(
+         :destination => "http://foo.com/bla.mp4",
+         :stretch     => false,
+         :rate        => 'every 10s',
+         :crop        => crop,
+         :size        => size
+       ).to_xml  
+     }
+
+     it "has a root element named capture" do
+       xml.root.name.should == 'output'
+     end
+
+     it "has the correct value for the rate attribute" do
+       xml.xpath("//output/capture/rate").text.should == "every 10s"
+     end
+
+     it "has the correct value for the destination attribute" do
+       xml.xpath("//output/capture/destination").text.should == "http://foo.com/bla.mp4"
+     end
+
+     it "has the correct value for the crop attribute" do
+       xml.xpath("//output/capture/crop/width").text.should == "125"
+       xml.xpath("//output/capture/crop/height").text.should == "140"
+     end
+
+     it "has the correct value for the size attribute" do
+       xml.xpath("//output/capture/size/width").text.should == "400"
+       xml.xpath("//output/capture/size/height").text.should == "500"
+     end
+  end
+end
+
+describe UEncode::Crop do
+  subject { described_class.new :width => 100, :height => 200, :x => 100, :y => 150 }
+
+  its(:width) { should == 100 }
+  its(:height) { should == 200 }
+  its(:x) { should == 100 }
+  its(:y) { should = 150 }
+
+  describe "#to_xml" do
+    let(:xml) { Nokogiri::XML described_class.new(:width => 100, :height => 200, :x => 100, :y => 150).to_xml }
+
+    it "has a root element named 'crop'" do
+      xml.root.name.should == 'crop'
+    end
+
+    it "has the correct value for the width attribute" do
+      xml.xpath("//width").text.should == "100"
+    end
+
+    it "has the correct value for the height attribute" do
+      xml.xpath("//height").text.should == "200"
+    end
+
+    it "has the correct value for the x attribute" do
+      xml.xpath("//x").text.should == "100"
+    end
+
+    it "has the correct value for the y attribute" do
+      xml.xpath("//y").text.should == "150"
+    end
+  end
+end
+
+shared_examples_for "an element that represents a rate number" do
+  subject { described_class.new :numerator => numerator, :denominator => denominator }
+
+  its(:numerator) { should == numerator }
+  its(:denominator) { should == denominator }
+
+  describe "#to_xml" do
+    let(:xml) { Nokogiri::XML described_class.new(:numerator => numerator, :denominator => denominator).to_xml }
+    
+    it "has a root element named '#{name}'" do
+      xml.root.name.should == name
+    end
+
+    it "has the correct value for the numerator attribute" do
+      xml.xpath("//numerator").text.should == numerator.to_s
+    end
+
+    it "has the correct value for the denominator attribute" do
+      xml.xpath("//denominator").text.should == denominator.to_s
+    end
+  end  
+end
+
+describe UEncode::FrameRate do
+  let(:name) { "framerate" }
+  let(:numerator) { 1000 }
+  let(:denominator) { 1001 }
+
+  it_should_behave_like "an element that represents a rate number"
+end
+
+describe UEncode::Par do
+  let(:name) { "par" }
+  let(:numerator) { 10 }
+  let(:denominator) { 11 }
+
+  it_should_behave_like "an element that represents a rate number"
+end
+
+describe UEncode::Size do
+  subject { described_class.new :width => 100, :height => 200 }
+
+  its(:height) { should == 200 }
+  its(:width) { should == 100 }
+
+  describe "#to_xml" do
+    let(:xml) { Nokogiri::XML described_class.new(:width => 200, :height => 250).to_xml }
+
+    it "has a root element named 'size'" do
+      xml.root.name.should == 'size'
+    end
+
+    it "has the correct value for the width attribute" do
+      xml.xpath("//width").text.should == "200"
+    end
+
+    it "has the correct value for the height attribute" do
+      xml.xpath("//height").text.should == "250"
+    end
+  end
+end
+
+describe UEncode::Job do
+  subject { described_class.new :source => "http://foo.com/bar.avi", :userdata => "some text", :notify => "http://my_url.com" }
+
+  its(:source) { should == "http://foo.com/bar.avi" }
+  its(:userdata) { should == "some text" }
+  its(:notify) { should == "http://my_url.com" }
+  its(:items) { should == [] }
+
+  describe "#<<" do
+    it "adds new elements to items" do
+      subject << "foo"
+      subject.items.should == ["foo"]
+    end
+  end
+
+  it "is enumerable" do
+    subject << "foo"
+    subject << "bar"
+    subject.map { |item| item }.should == ["foo", "bar"]
+  end
+
+  describe "#to_xml" do
+    let(:job) { UEncode::Job.new({
+      :customerkey => "0123456789",
+      :source      => "http://whatever.com/foo.avi",
+      :userdata    => "some text",
+      :notify      => "http://notify.me/meh"
+    })}
+
+    let(:xml) { Nokogiri::XML job.to_xml }
+
+    before :each do
+      video1 = UEncode::Medium.new
+      video1.configure_video do |c|
+        c.bitrate = 1000
+        c.codec   = 'mp4'
+      end
+      video1.configure_audio do |c|
+        c.codec = 'aac'
+      end
+      video2 = UEncode::Medium.new
+      video2.configure_video do |c|
+        c.bitrate = 1500
+        c.codec   = 'mpeg2'
+      end
+      video2.configure_audio do |c|
+        c.codec = 'passthru'
+      end
+      job << video1
+      job << video2
+
+      job.configure_video_output do |c|
+        c.destination = "http://whatever.com/foo1.mp4"
+        c.container   = "mpeg4"
+      end
+
+      capture1 = UEncode::CaptureOutput.new :destination => "http://whatever.com/foo.zip", :rate => "every 30s"
+      job.add_capture capture1
+      capture2 = UEncode::CaptureOutput.new :destination => "http://whatever.com/bar.zip", :rate => "every 10s"
+      job.add_capture capture2
+    end
+
+    it "has a root element named 'job'" do
+      xml.root.name.should == 'job'
+    end
+
+    it "has the correct customer key value" do
+      xml.xpath("//job/customerkey").text.should == "1q2w3e4r5t"
+    end
+
+    it "has the correct source attribute" do
+      xml.xpath("//job/source").text.should == "http://whatever.com/foo.avi"
+    end
+
+    it "has the correct user data value" do
+      xml.xpath("//job/userdata").text.should == 'some text'
+    end
+
+    it "has the correct notify value" do
+      xml.xpath("//job/notify").text.should == "http://notify.me/meh"
+    end
+
+    it "does not include the userdata attribute when it's null" do
+      job.instance_variable_set :@userdata, nil
+      xml.xpath("//job/userdata").should be_empty
+    end
+
+    it "does not include the notify attribute when it's null" do
+      job.instance_variable_set :@notify, nil
+      xml.xpath("//job/notify").should be_empty
+    end
+
+    it "contains the correct content to represent each video output item" do
+      xml.xpath("//job/outputs/output/video/media/medium").length.should == 2
+    end
+
+    it "has the correct video output destination" do
+      xml.xpath("//job/outputs/output/video/destination").text.should == "http://whatever.com/foo1.mp4"
+    end
+
+    it "has the correct video output container" do
+      xml.xpath("//job/outputs/output/video/container").text.should == "mpeg4"
+    end
+
+    it "contains the correct content to represent the video captures" do
+      xml.xpath("//job/outputs/output/capture").length.should == 2
+    end
+  end
+end

data/spec/fixtures/job_with_one_video_and_no_capture.yml

@@ -0,0 +1,87 @@
+--- 
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :put
+    uri: https://www.uencode.com:443/jobs?version=300
+    body: |
+      <?xml version="1.0"?>
+      <job>
+                <customerkey>1q2w3e4r5t</customerkey>
+                <source>http://dailydigital-files.s3.amazonaws.com/staging/3/iphone.mp4</source>
+                <userdata>This is a simple test</userdata>
+                
+                <outputs>
+                  
+              <output>
+                <video>
+                  <destination>http://dailydigital-files.s3.amazonaws.com/staging/3/iphone_transcoded.mp4</destination>
+                  <container>mpeg4</container>
+                  <media>
+                    
+              <medium>
+                <video>
+                  <bitrate>300000</bitrate>
+                  <codec>h264</codec>
+                  <cbr>false</cbr>
+                  
+                  <deinterlace>false</deinterlace>
+                  
+                  
+                  
+                  
+                  
+                  <profile>main</profile>
+                  <passes>1</passes>
+                  
+                  
+                </video>
+                <audio>
+                  <codec>aac</codec>
+                  <bitrate>64000</bitrate>
+                  <channels>1</channels>
+                  <samplerate>44100</samplerate>
+                </audio>
+              </medium>
+            
+                  </media>
+                </video>
+              </output>
+            
+                  
+                </outputs>
+              </job>
+
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      date: 
+      - Wed, 18 May 2011 21:25:41 GMT
+      server: 
+      - Apache/2.2.16 (Ubuntu)
+      etag: 
+      - "\"1c1e90e26e3f60eeb74014a6aeb5ac22\""
+      cache-control: 
+      - max-age=0, private, must-revalidate
+      x-ua-compatible: 
+      - IE=Edge,chrome=1
+      set-cookie: 
+      - _uencode_api_session=BAh7BiIPc2Vzc2lvbl9pZCIlOWM4ZWM4ZGUxMzNiNTNiNWZiOWMwMDA4ODkzMmY3ZWI%3D--697ce08be3ca2a9f6347474fe7fe5476333e9408; path=/; HttpOnly
+      x-runtime: 
+      - "1.007000"
+      content-length: 
+      - "202"
+      content-type: 
+      - application/xml;charset=utf-8
+    body: |
+      <?xml version="1.0" encoding="UTF-8"?>
+      <response>
+        <code>Ok</code>
+        <jobid>6068</jobid>
+        <message>You job was created successfully.</message>
+        <userdata>This is a simple test</userdata>
+      </response>
+
+    http_version: "1.1"

data/spec/request_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe UEncode::Request do
+  context "being created" do
+    let(:job) { UEncode::Job.new :source => "http://whatever.com/foo/avi" }
+    let(:request) { UEncode::Request.new job }
+
+    it "initializes the job attribute" do
+      request.instance_variable_get(:@job).should == job
+    end
+  end
+
+  describe "#send" do
+    let(:job) { UEncode::Job.new :source => "http://dailydigital-files.s3.amazonaws.com/staging/3/iphone.mp4", :userdata => "This is a simple test" }
+    let(:request) { UEncode::Request.new job }
+
+    before :each do
+      job.configure_video_output do |c| 
+        c.destination = "http://dailydigital-files.s3.amazonaws.com/staging/3/iphone_transcoded.mp4"
+        c.container   = "mpeg4"
+      end
+      video1 = UEncode::Medium.new
+      video1.configure_video { |c| c.bitrate = 300000; c.codec = "h264"}
+      video1.configure_audio do |c| 
+        c.bitrate    = 64000
+        c.codec      = "aac"
+        c.samplerate = 44100
+        c.channels   = 1
+      end
+      job << video1
+    end
+
+    around :each do |example|
+      VCR.use_cassette "job_with_one_video_and_no_capture", &example
+    end
+
+    it "returns a response containing the jobid" do
+      request.send.jobid.should =~ /\A\d+\z/
+    end
+
+    it "returns a response containing a code" do
+      request.send.code.should == 'Ok'
+    end
+
+    it "returns a response containing the previously sent user data" do
+      request.send.userdata.should == "This is a simple test"
+    end
+
+    it "returns a response containing a message" do
+      request.send.message.should == "You job was created successfully."
+    end
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe UEncode::Response do
+  context "errors" do
+    let(:response) { UEncode::Response.new :code => code, :message => "whatever" }
+
+    context "when initialized with a 'BadRequest' code" do
+      let(:code) { 'BadRequest' }
+
+      it "raises a UEncode::Response::BadRequestError error containing the error message" do
+        expect { response }.to raise_error(UEncode::Response::BadRequestError, "whatever")
+      end
+    end
+
+    context "when initialized with a 'InvalidKey' code" do
+      let(:code) { 'InvalidKey' }
+
+      it "raises a UEncode::Response::InvalidKeyError containing the error message" do
+        expect { response }.to raise_error(UEncode::Response::InvalidKeyError, "whatever")
+      end
+    end
+
+    context "when initialized with a 'NotActive' code" do
+      let(:code) { 'NotActive' }
+
+      it "raises a UEncode::Response::NotActiveError containing the error message" do
+        expect { response }.to raise_error(UEncode::Response::NotActiveError, "whatever")
+      end
+    end
+
+    context "when initialized with a 'ServerError' code" do
+      let(:code) { 'ServerError' }
+
+      it "raises a UEncode::Response::ServerError containing the error message" do
+        expect { response }.to raise_error(UEncode::Response::ServerError, "whatever")
+      end
+    end
+
+    context "when initialized with an unknown code" do
+      let(:code) { 'Ffffuuuuu' }
+
+      it "raises a UEncode::Response::UnknownError containing the error code and the error message" do
+        expect { response }.to raise_error(UEncode::Response::UnknownError, "Ffffuuuuu: whatever")
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'uencode'
+require 'rspec'
+require 'rspec/autorun'
+require "vcr"
+
+
+VCR.config do |c|
+  library_dir = File.join(File.dirname(__FILE__), 'fixtures/')
+  c.cassette_library_dir = library_dir
+  c.stub_with :webmock
+  c.allow_http_connections_when_no_cassette = false
+  c.ignore_localhost = true
+end
+
+UEncode.configure do |c|
+  c.customer_key = "1q2w3e4r5t"
+end

data/spec/uencode_spec.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'spec_helper'
+
+describe UEncode do
+  it "has a customer_key configuration parameter" do
+    UEncode.configure do |c|
+      c.customer_key = "1234567890"
+    end
+    UEncode.customer_key.should == "1234567890"
+  end
+end
+

data/uencode.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "uencode/version"
+
+Gem::Specification.new do |s|
+  s.name        = "uencode"
+  s.version     = UEncode::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Cássio Marques"]
+  s.email       = ["cassiommc@gmail.com"]
+  s.homepage    = "http://github.com/cassiomarques/uencode"
+  s.summary     = %q{Simple UEncode API client written in Ruby}
+  s.description = %q{UEncode API client}
+
+  s.rubyforge_project = "uencode"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", "2.6.0"
+  s.add_development_dependency "vcr", "1.9.0"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "growl"
+  s.add_development_dependency "rb-fsevent"
+  s.add_development_dependency "webmock"
+
+  s.add_dependency "nokogiri", "1.4.4"
+  s.add_dependency "httparty"
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification 
+name: uencode
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "C\xC3\xA1ssio Marques"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-18 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: vcr
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.9.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: guard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: growl
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rb-fsevent
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.4.4
+  type: :runtime
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id009
+description: UEncode API client
+email: 
+- cassiommc@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gitignore
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- lib/uencode.rb
+- lib/uencode/elements.rb
+- lib/uencode/request.rb
+- lib/uencode/response.rb
+- lib/uencode/version.rb
+- spec/elements_spec.rb
+- spec/fixtures/job_with_one_video_and_no_capture.yml
+- spec/request_spec.rb
+- spec/response_spec.rb
+- spec/spec_helper.rb
+- spec/uencode_spec.rb
+- uencode.gemspec
+has_rdoc: true
+homepage: http://github.com/cassiomarques/uencode
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: uencode
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Simple UEncode API client written in Ruby
+test_files: 
+- spec/elements_spec.rb
+- spec/fixtures/job_with_one_video_and_no_capture.yml
+- spec/request_spec.rb
+- spec/response_spec.rb
+- spec/spec_helper.rb
+- spec/uencode_spec.rb