flixcloud-flix_cloud-gem 0.5.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Zencoder
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,104 @@
+FlixCloud Gem
+=============
+
+The gem for interacting with the API on [FlixCloud](http://flixcloud.com).
+
+See [http://flixcloud.com/api](http://flixcloud.com/api) for more details on the API.
+
+Examples
+========
+
+Rails
+-----
+
+If you're using rails, you can add the following to your environment.rb:
+
+    config.gem 'flixcloud-flix_cloud-gem', :lib => 'flix_cloud', :source => 'http://gems.github.com'
+    config.gem 'sevenwire-http_client', :lib => 'http_client', :source => 'http://gems.github.com'
+    config.gem 'crack'
+
+Then you can run:
+
+    rake gems:install
+    rake gems:unpack
+
+Ruby or Other Frameworks
+------------------------
+
+Install the gems (sudo may be necessary):
+
+    gem install flixcloud-flix_cloud-gem --source http://gems.github.com
+    gem install sevenwire-http_client --source http://gems.github.com
+    gem install crack
+
+Then in your code you can just require the FlixCloud gem:
+
+    require 'rubygems'
+    require 'flix_cloud'
+
+Creating Jobs
+-------------
+
+You can create jobs using the Job class:
+
+    job = FlixCloud::Job.new(:api_key => 'your-api-key-here',
+                             :recipe_id => 1,
+                             :input_url => 'http://url/to/your/input/file',
+                             :output_url => 'ftp://url/to/your/output/file',
+                             :output_user => 'username-for-ftp-here',
+                             :output_password => 'password-for-ftp-here',
+                             :watermark_url => 's3://url/to/your/watermark/file')
+    job.valid?         # true or false
+    job.save           # true or false
+    job.id             # returns the id of the saved job, or nil if it failed to save
+    job.initialized_at # returns the time the job was created, or nil if it failed to save
+
+Job is modeled after ActiveRecord, so create, create!, save, save!, etc all work.
+
+See [this](http://flixcloud.com/api#sending_jobs_to_flix_cloud) for more information.
+
+Job Notifications
+-----------------
+
+When you receive a notification from FlixCloud, you can process it using the Notification class:
+
+    job = FlixCloud::Notification.new(notification_xml_or_hash)
+    job.successful?                # true if the state is 'successful_job', false if not
+    job.failed?                    # true if the state is 'failed_job', false if not
+    job.cancelled?                 # true if the state is 'cancelled_job', false if not
+    job.id                         # the id of the job that finished
+    job.finished_job_at            # the time the job finished at
+    job.initialized_job_at         # the time the job was created at
+    job.recipe_name                # the name of the recipe used to process the job
+    job.recipe_id                  # the id of the recipe used to process the job
+    job.state                      # the state of the finished job. 'successful_job', 'failed_job', or 'cancelled_job'
+    job.error_message              # the error message given for the job if it failed to process
+    job.input_media_file.url       # url of the input file
+    job.input_media_file.width     # width of the input file in pixels
+    job.input_media_file.height    # height of the input file in pixels
+    job.input_media_file.size      # size of the input file in bytes
+    job.input_media_file.duration  # duration of the input file in milliseconds
+    job.input_media_file.cost      # cost of the input file in millicents (1/1000th of a cent)
+    job.output_media_file.url      # url of the output file
+    job.output_media_file.width    # width of the output file in pixels
+    job.output_media_file.height   # height of the output file in pixels
+    job.output_media_file.size     # size of the output file in bytes
+    job.output_media_file.duration # duration of the output file in milliseconds
+    job.output_media_file.cost     # cost of the output file in millicents (1/1000th of a cent)
+    job.watermark_file.url         # url of the watermark file
+    job.watermark_file.size        # size of the watermark file in bytes
+    job.watermark_file.cost        # cost of the watermark file in millicents (1/1000th of a cent)
+
+See [this](http://flixcloud.com/api#job_notifications) for more information.
+
+Note
+----
+
+Creating jobs sends HTTP requests to FlixCloud, which may take some time. It's
+best to do this asynchronously in your application.
+
+
+COPYRIGHT
+=========
+
+Copyright (c) 2009 Zencoder. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "flix_cloud-gem"
+    gem.summary = %{Gem for integrating with http://flixcloud.com}
+    gem.email = "nate@sevenwire.com"
+    gem.homepage = "http://github.com/zencoder/flix_cloud-gem"
+    gem.authors = ["Nathan Sutton"]
+    gem.add_dependency('builder', '>= 2.1.2')
+    gem.add_dependency('crack', '>= 0.1.1')
+    gem.add_dependency('sevenwire-http_client', '>= 0.1.0')
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "flix_cloud-gem #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 5
+:patch: 3

data/lib/flix_cloud/exceptions.rb

@@ -0,0 +1,6 @@
+class FlixCloud::Error < StandardError; end
+class FlixCloud::SaveError < FlixCloud::Error; end
+class FlixCloud::CreateError < FlixCloud::Error; end
+class FlixCloud::ServerBrokeConnection < FlixCloud::Error; end
+class FlixCloud::RequestTimeout < FlixCloud::Error; end
+class FlixCloud::ConnectionRefused < FlixCloud::Error; end

data/lib/flix_cloud/extensions/hash.rb

@@ -0,0 +1,22 @@
+module FlixCloud
+  module Extensions
+    # Both methods ripped directly out of rails
+    module Hash
+      def deep_merge(other_hash)
+        self.merge(other_hash) do |key, oldval, newval|
+          oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+          newval = newval.to_hash if newval.respond_to?(:to_hash)
+          oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? oldval.deep_merge(newval) : newval
+        end
+      end
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      # Modifies the receiver in place.
+      def deep_merge!(other_hash)
+        replace(deep_merge(other_hash))
+      end
+    end
+  end
+end
+
+Hash.send(:include, FlixCloud::Extensions::Hash) unless Hash.instance_methods.include?('deep_merge')

data/lib/flix_cloud/file.rb

@@ -0,0 +1,21 @@
+class FlixCloud::File < FlixCloud::Record
+
+  attr_accessor :url, :size, :width, :height, :duration, :cost
+
+  record_column :parameters, 'Parameters'
+
+  def valid?
+    self.errors = []
+
+    unless url
+      self.errors << "url is required"
+    end
+
+    if parameters && !parameters.valid?
+      self.errors << {:parameters => parameters.errors}
+    end
+
+    errors.empty?
+  end
+
+end

data/lib/flix_cloud/file_locations.rb

@@ -0,0 +1,33 @@
+class FlixCloud::FileLocations < FlixCloud::Record
+
+  record_column :input, 'File'
+  record_column :output, 'File'
+  record_column :watermark, 'File'
+
+  def valid?
+    self.errors = []
+
+    if input
+      unless input.valid?
+        self.errors << {:input => input.errors}
+      end
+    else
+      self.errors << "input is required"
+    end
+
+    if output
+      unless output.valid?
+        self.errors << {:output => output.errors}
+      end
+    else
+      self.errors << "output is required"
+    end
+
+    if watermark && !watermark.valid?
+      self.errors << {:watermark => watermark.errors}
+    end
+
+    errors.empty?
+  end
+
+end

data/lib/flix_cloud/job.rb

@@ -0,0 +1,150 @@
+class FlixCloud::Job < FlixCloud::Record
+
+  attr_accessor :id, :initialized_at, :api_key, :recipe_id, :recipe_name, :response
+
+  record_column :file_locations, 'FileLocations'
+
+  def initialize(attrs={})
+    super
+    self.shortcut_attributes = attrs
+  end
+
+  def valid?
+    self.errors = []
+
+    if file_locations
+      unless file_locations.valid?
+        self.errors << {:file_locations => file_locations.errors}
+      end
+    else
+      self.errors << "file_locations is required"
+    end
+
+    if recipe_id || recipe_name
+      if recipe_id && recipe_name
+        self.errors << "recipe_id and recipe_name cannot both be used"
+      end
+    else
+      self.errors << "recipe_id or recipe_name is required"
+    end
+
+    unless api_key
+      self.errors << "api_key is required"
+    end
+
+    errors.empty?
+  end
+
+  def save
+    return false unless valid?
+
+    self.response = post('jobs', to_xml)
+
+    if response.success?
+      self.id = response.body_as_hash['job']['id']
+      self.initialized_at = response.body_as_hash['job']['initialized_job_at']
+    else
+      self.errors = response.errors
+    end
+
+    response.success?
+  end
+
+  def save!
+    raise FlixCloud::SaveError unless save
+    true
+  end
+
+  def self.create(attrs={})
+    job = new(attrs)
+    job.save
+    job
+  end
+
+  def self.create!(attrs={})
+    job = create(attrs)
+    raise FlixCloud::CreateError unless job.id
+    job
+  end
+
+  def to_xml
+    xml = Builder::XmlMarkup.new
+
+    xml.instruct! :xml, :version => "1.0", :encoding => "UTF-8"
+
+    xml.tag!("api-request") do
+      xml.tag!("api-key", api_key)
+
+      if recipe_name
+        xml.tag!("recipe-name", recipe_name)
+      else
+        xml.tag!("recipe-id", recipe_id)
+      end
+
+      if file_locations
+        xml.tag!("file-locations") do
+          if file_locations.input
+            xml.input do
+              xml.url(file_locations.input.url)
+              if file_locations.input.parameters
+                xml.parameters do
+                  xml.user(file_locations.input.parameters.user)
+                  xml.password(file_locations.input.parameters.password)
+                end
+              end
+            end
+          end
+
+          if file_locations.output
+            xml.output do
+              xml.url(file_locations.output.url)
+              if file_locations.output.parameters
+                xml.parameters do
+                  xml.user(file_locations.output.parameters.user)
+                  xml.password(file_locations.output.parameters.password)
+                end
+              end
+            end
+          end
+
+          if file_locations.watermark
+            xml.watermark do
+              xml.url(file_locations.watermark.url)
+              if file_locations.watermark.parameters
+                xml.parameters do
+                  xml.user(file_locations.watermark.parameters.user)
+                  xml.password(file_locations.watermark.parameters.password)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    xml.target!
+  end
+
+
+protected
+
+  def shortcut_attributes=(attrs)
+    translated_attributes = {}
+
+    attrs.each do |key, value|
+      if match = key.to_s.match(/^(input|output|watermark)_(url|user|password)$/)
+        file_type = match[1].to_sym
+        parameter_type = match[2].to_sym
+
+        if parameter_type == :url
+          translated_attributes.deep_merge!(:file_locations => { file_type => { :url => value}})
+        else
+          translated_attributes.deep_merge!(:file_locations => { file_type => { :parameters => { parameter_type => value}}})
+        end
+      end
+    end
+
+    self.attributes = translated_attributes unless translated_attributes.empty?
+  end
+
+end

data/lib/flix_cloud/notification.rb

@@ -0,0 +1,32 @@
+class FlixCloud::Notification < FlixCloud::Record
+  attr_accessor :xml, :id, :finished_job_at, :initialized_job_at,
+                :recipe_name, :recipe_id, :state, :error_message
+
+  record_column :input_media_file, 'File'
+  record_column :output_media_file, 'File'
+  record_column :watermark_file, 'File'
+
+  def initialize(attrs={})
+    if attrs.is_a?(String)
+      self.xml = attrs
+      attrs = Crack::XML.parse(attrs)
+    end
+
+    attrs = attrs['job'] if attrs['job']
+
+    super(attrs)
+  end
+
+  def successful?
+    state == 'successful_job'
+  end
+
+  def failed?
+    state == 'failed_job'
+  end
+
+  def cancelled?
+    state == 'cancelled_job'
+  end
+
+end

data/lib/flix_cloud/parameters.rb

@@ -0,0 +1,19 @@
+class FlixCloud::Parameters < FlixCloud::File
+
+  attr_accessor :user, :password
+
+  def valid?
+    self.errors = []
+
+    unless user
+      self.errors << "user is required"
+    end
+
+    unless password
+      self.errors << "password is required"
+    end
+
+    errors.empty?
+  end
+
+end

data/lib/flix_cloud/record.rb

@@ -0,0 +1,46 @@
+class FlixCloud::Record
+
+  attr_accessor :errors
+
+  def initialize(attrs={})
+    self.errors = []
+    self.attributes = attrs
+  end
+
+  def attributes=(attrs)
+    attrs.each do |key, value|
+      send("#{key}=", value) if respond_to?("#{key}=")
+    end
+  end
+
+  def self.record_column(attribute, klass)
+    eval %{
+      attr_reader :#{attribute}
+
+      def #{attribute}=(value)
+        if @#{attribute}
+          @#{attribute}.attributes = value
+        else
+          @#{attribute} = FlixCloud::#{klass}.new(value)
+        end
+      end
+    }
+  end
+
+
+protected
+
+  def post(path, body)
+    begin
+      FlixCloud::Response.new(HttpClient::Resource.new("https://flixcloud.com/#{path}",
+                                                       :verify_ssl => OpenSSL::SSL::VERIFY_PEER).post(body, :content_type => 'application/xml', :accept => 'application/xml'))
+    rescue HttpClient::ServerBrokeConnection
+      raise FlixCloud::ServerBrokeConnection, $!.message
+    rescue HttpClient::RequestTimeout
+      raise FlixCloud::RequestTimeout, $!.message
+    rescue HttpClient::ConnectionRefused
+      raise FlixCloud::ConnectionRefused, $!.message
+    end
+  end
+
+end

data/lib/flix_cloud/response.rb

@@ -0,0 +1,26 @@
+class FlixCloud::Response
+
+  attr_accessor :code, :body, :errors, :body_as_hash
+
+  def initialize(response)
+    self.code = response.code
+    self.body = response.to_s
+    self.body_as_hash = Crack::XML.parse(response.to_s)
+    self.errors = []
+    process_response_xml
+  end
+
+  def success?
+    201 == code.to_i
+  end
+
+
+protected
+
+  def process_response_xml
+    if body_as_hash['errors'] && body_as_hash['errors'].is_a?(Hash) && body_as_hash['errors']['error']
+      self.errors = Array(body_as_hash['errors']['error'])
+    end
+  end
+
+end

data/lib/flix_cloud.rb

@@ -0,0 +1,10 @@
+require 'builder'
+require 'http_client'
+require 'crack/xml'
+
+module FlixCloud; end
+
+%w(record job file_locations file parameters response extensions/hash
+   exceptions notification).each do |file|
+  require File.dirname(__FILE__) + "/flix_cloud/#{file}"
+end

data/test/flix_cloud/file_locations_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class FlixCloud::FileLocationsTest < Test::Unit::TestCase
+
+  context "When validationg a file locations object with no attributes set" do
+    setup do
+      @file_locations = FlixCloud::FileLocations.new
+      @file_locations.valid?
+    end
+
+    should "require input" do
+      assert_match /input is required/, @file_locations.errors.to_s
+    end
+
+    should "require output" do
+      assert_match /output is required/, @file_locations.errors.to_s
+    end
+  end
+
+  context "When validating a file locations object with input, output, and watermark objects that are invalid" do
+    setup do
+      @file_locations = FlixCloud::FileLocations.new(:input => {}, :output => {}, :watermark => {})
+      @file_locations.valid?
+    end
+
+    should "inherit the input object's errors" do
+      assert @file_locations.errors.any?{|error|
+        error.is_a?(Hash) && error[:input] && !error[:input].empty?
+      }, "Did not inherit input object's errors"
+    end
+
+    should "inherit the output object's errors" do
+      assert @file_locations.errors.any?{|error|
+        error.is_a?(Hash) && error[:output] && !error[:output].empty?
+      }, "Did not inherit output object's errors"
+    end
+
+    should "inherit the watermark object's errors" do
+      assert @file_locations.errors.any?{|error|
+        error.is_a?(Hash) && error[:watermark] && !error[:watermark].empty?
+      }, "Did not inherit watermark object's errors"
+    end
+  end
+
+end

data/test/flix_cloud/file_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class FlixCloud::FileTest < Test::Unit::TestCase
+
+  context "When validating a file object with no attributes set" do
+    setup do
+      @file = FlixCloud::File.new
+      @file.valid?
+    end
+
+    should "require url" do
+      assert_match /url is required/, @file.errors.to_s
+    end
+  end
+
+  context "When validating a file object with a parameters object that is invalid" do
+    setup do
+      @file = FlixCloud::File.new(:parameters => {})
+      @file.valid?
+    end
+
+    should "inherit the parameters object's errors" do
+      assert @file.errors.any?{|error|
+        error.is_a?(Hash) && error[:parameters] && !error[:parameters].empty?
+      }, "Did not inherit parameters object's errors"
+    end
+  end
+
+end