transloadit 0.1.0

data/.gitignore

@@ -0,0 +1,9 @@
+.bundle
+.rvmrc
+.yardoc
+
+Gemfile.lock
+
+coverage
+doc
+pkg

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,142 @@
+# transloadit
+
+Fantastic file uploading for your web application.
+
+## Description
+
+This is the official Ruby gem for [Transloadit](transloadit.com). It allows
+you to automate uploading files through the Transloadit REST API.
+
+## Install
+
+    gem install transloadit
+
+## Getting started
+
+To get started, you need to require the 'transloadit' gem:
+
+    $ irb -rubygems
+    >> require 'transloadit'
+    => true
+
+Then create a Transloadit instance, which will maintain your authentication
+credentials and allow us to make requests to the API.
+
+    transloadit = Transloadit.new(
+      key:    'transloadit-auth-key',
+      secret: 'transloadit-auth-secret'
+    )
+
+### 1. Resize and store an image
+
+This example demonstrates how you can create an assembly to resize an image
+and store the result on [Amazon S3](http://aws.amazon.com/s3/).
+
+First, we create two steps: one to resize the image to 320x240, and another to
+store the image in our S3 bucket.
+
+    resize = transloadit.step '/image/resize',
+      width:  320,
+      height: 240
+
+    store  = transloadit.step '/s3/store',
+      key:    'aws-access-key-id',
+      secret: 'aws-secret-access-key',
+      bucket: 's3-bucket-name'
+
+Now that we have the steps, we create an assembly (which is just a request to
+process a file or set of files) and let Transloadit do the rest.
+
+    assembly = transloadit.assembly(
+      steps: [ resize, store ]
+    )
+    
+    response = assembly.submit! open('lolcat.jpg')
+
+When the `submit!` method returns, the file has been uploaded but may not yet
+be done processing. We can use the returned object to check if processing has
+completed, or examine other attributes of the request.
+
+    # returns the unique API ID of the assembly
+    response[:assembly_id] # => '9bd733a...'
+    
+    # returns the API URL endpoint for the assembly
+    response[:assembly_url] # => 'http://api2.vivian.transloadit.com/assemblies/9bd733a...'
+    
+    # checks how many bytes were expected / received by transloadit
+    response[:bytes_expected] # => 92933
+    response[:bytes_received] # => 92933
+    
+    # checks if all processing has been completed
+    response.completed? # => false
+    
+    # cancels further processing on the assembly
+    response.cancel! # => true
+
+It's important to note that none of these queries are "live" (with the
+exception of the `cancel!` method). They all check the response given by the
+API at the time the assembly was created. You have to explicitly ask the
+assembly to reload its results from the API.
+
+    # reloads the response's contents from the REST API
+    response.reload!
+
+In general, you use hash accessor syntax to query any direct attribute from
+the [response](http://transloadit.com/docs/assemblies#response-format).
+Methods suffixed by a question mark provide a more readable way of quering
+state (e.g., `assembly.completed?` vs. checking the result of
+`assembly[:ok]`). Methods suffixed by a bang make a live query against the
+Transloadit HTTP API.
+
+### 2. Uploading multiple files
+
+Multiple files can be given to the `submit!` method in order to upload more
+than one file in the same request. You can also pass a single step for the
+`steps` parameter, without having to wrap it in an Array.
+    
+    assembly = transloadit.assembly(steps: store)
+    
+    response = assembly.submit!(
+      open('puppies.jpg'),
+      open('kittens.jpg'),
+      open('ferrets.jpg')
+    )
+
+### 3. Parallel Assembly
+
+Transloadit allows you to perform several processing steps in parallel. You
+simply need to `use` other steps. Following 
+[their example](http://transloadit.com/docs/assemblies#special-parameters):
+
+    encode = transloadit.step '/video/encode', { ... }
+    thumbs = transloadit.step '/video/thumbs', { ... }
+    export = transloadit.step '/s3/store',     { ... }
+    
+    export.use [ encode, thumbs ]
+    
+    transloadit.assembly(
+      steps: [ encode, thumbs, export ]
+    ).submit! open('ninja-cat.mpg')
+
+You can also tell a step to use the original uploaded file by passing the
+Symbol `:original` instead of another step.
+
+Check the YARD documentation for more information on using
+[use](http://rubydoc.info/gems/transloadit/frames/Transloadit/Step#use-instance_method).
+
+## Documentation
+
+Up-to-date YARD documentation is automatically generated. You can view the
+docs for the [released gem](http://rubydoc.info/gems/transloadit/frames) or
+for the latest [git master](http://rubydoc.info/github/transloadit/ruby-sdk/master/frames).
+
+## Compatibility
+
+At a minimum, this gem should work on MRI 1.9.2, 1.8.7, 1.8.6, and Rubinius
+1.2.0. If it doesn't, please file a [bug report](https://github.com/transloadit/ruby-sdk/issues).
+Compatibility patches for other Rubies are welcomed.
+
+You can run `rake test:multiruby` to test transloadit against all supported
+Rubies. Run `rake test:multiruby:setup` once beforehand, though, to set up the
+RVM environments. [RVM](rvm.beginrescueend.com/) must be installed in order to
+test against multiple Rubies.

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+RUBIES = %w{ 1.9.2 1.8.7 1.8.6 rbx-1.2.0 }
+
+GEMSPEC = 'transloadit.gemspec'
+
+spec = eval open(GEMSPEC).read
+Rake::GemPackageTask.new(spec) do |gem|
+  gem.need_tar = true
+end
+
+Rake::TestTask.new do |test|
+  test.libs   << 'test'
+  test.pattern = 'test/**/test_*.rb'
+end
+
+namespace :test do
+  begin
+    `rvm -v` # raise an exception if RVM isn't installed
+    
+    desc 'Run tests against all supported Rubies'
+    task :multiruby do
+      system "rvm #{RUBIES.join(',')} ruby bundle exec rake -s test"
+      
+      # clean up after Rubinius
+      require 'pathname'
+      Pathname.glob('**/*.rbc').each {|path| path.unlink }
+    end
+    
+    namespace :multiruby do
+      desc 'Prepare supported rubiesfor testing'
+      task :setup do
+        warn 'Preparing multiruby. This may take awhile...'
+        
+        # create gemsets, install bundler, bundle
+        RUBIES.each {|ruby| system "rvm #{ruby} gemset create transloadit" }
+        system "rvm #{RUBIES.join(',')} gem install bundler --no-ri --no-rdoc"
+        system "rvm #{RUBIES.join(',')} ruby bundle install"
+      end
+    end
+  rescue Errno::ENOENT
+    desc 'You need `rvm` installed to test against multiple Rubies'
+    task :multiruby
+  end
+end
+
+begin
+  require 'yard'
+  require 'yard/rake/yardoc_task'
+  
+  YARD::Rake::YardocTask.new :doc do |yard|
+    yard.options = %w{
+      --title  Transloadit
+      --readme README.md
+      --markup rdoc
+    }
+  end
+rescue
+  desc 'You need the `yard` gem to generate documentation'
+  task :doc
+end

data/lib/transloadit.rb

@@ -0,0 +1,114 @@
+require 'json'
+
+#
+# Implements the Transloadit REST API in Ruby. Check the {file:README.md README}
+# for usage instructions.
+#
+class Transloadit
+  autoload :Assembly, 'transloadit/assembly'
+  autoload :Request,  'transloadit/request'
+  autoload :Response, 'transloadit/response'
+  autoload :Step,     'transloadit/step'
+  autoload :VERSION,  'transloadit/version'
+  
+  # @return [String] your Transloadit auth key
+  attr_accessor :key
+  
+  # @return [String] your Transloadit auth secret, for signing requests
+  attr_accessor :secret
+  
+  #
+  # Creates a new instance of the Transloadit API.
+  #
+  # @param [Hash] options a hash of options, which can be any of:
+  # @option options [String] :key your auth key from the
+  #   {credentials}[https://transloadit.com/accounts/credentials] page
+  #   (required)
+  # @option options [String] :secret your auth secret from the
+  #   {credentials}[https://transloadit.com/accounts/credentials] page, for
+  #   signing requests (optional)
+  #
+  def initialize(options = {})
+    self.key    = options[:key]
+    self.secret = options[:secret]
+    
+    _ensure_key_provided
+  end
+  
+  #
+  # Creates a Transloadit::Step describing a step in an upload assembly.
+  #
+  # @param  [String] robot the robot to use in this step (e.g., '/image/resize')
+  # @param  [Hash]   options a hash of options to customize the robot's
+  #   operation; see the {online documentation}[http://transloadit.com/docs/building-assembly-instructions]
+  #   for robot-specific options
+  # @return [Step]   the created Step
+  #
+  def step(robot, options = {})
+    Transloadit::Step.new(robot, options)
+  end
+  
+  #
+  # Creates a Transloadit::Assembly ready to be sent to the REST API.
+  #
+  # @param [Hash] options additional parameters to send with the assembly
+  #   submission; for a full list of parameters, see the official
+  #   documentation on {templates}[http://transloadit.com/docs/templates].
+  # @option options [Step, Array<Step>] :steps the steps to perform in this
+  #   assembly
+  # @option options [String] :notify_url A URL to be POSTed when the assembly
+  #   has finished processing
+  # @option options [String] :template_id the ID of a
+  #   {template}[https://transloadit.com/templates] to use instead of
+  #   specifying options here directly
+  #
+  def assembly(options = {})
+    Transloadit::Assembly.new(self, options)
+  end
+  
+  #
+  # @return [String] a human-readable version of the Transloadit.
+  #
+  def inspect
+    self.to_hash.inspect
+  end
+  
+  #
+  # @return [Hash] a Transloadit-compatible Hash of the instance's contents
+  #
+  def to_hash
+    result = { :key => self.key }
+    result.update(:expires => _generate_expiry) unless self.secret.nil?
+    result
+  end
+  
+  #
+  # @return [String] JSON-encoded String containing the object's hash contents
+  #
+  def to_json
+    self.to_hash.to_json
+  end
+  
+  private
+  
+  #
+  # Raises an ArgumentError if no {#key} has been assigned.
+  #
+  def _ensure_key_provided
+    unless self.key
+      raise ArgumentError, 'an authentication key must be provided'
+    end
+  end
+  
+  #
+  # Automatically generates API-compatible request expiration times 5 minutes
+  # from now.
+  #
+  # @param [Integer] duration the number of seconds from now to set the
+  #   expiry time
+  # @return [String] an API-compatible timestamp
+  #
+  def _generate_expiry(duration = 5 * 60)
+    (Time.now + duration).utc.strftime('%Y/%m/%d %H:%M:%S+00:00')
+  end
+end

data/lib/transloadit/assembly.rb

@@ -0,0 +1,122 @@
+require 'transloadit'
+
+#
+# Represents a Assembly ready to be sent to the REST API for processing. An
+# Assembly can contain one or more Steps for processing or point to a
+# server-side template. It's submitted along with a list of files to process,
+# at which point Transloadit will process and store the files according to the
+# rules in the Assembly.
+#
+# See the Transloadit {documentation}[http://transloadit.com/docs/building-assembly-instructions]
+# for futher information on Assemblies and their parameters.
+#
+class Transloadit::Assembly
+  # @return [Transloadit] the associated Transloadit instance
+  attr_reader   :transloadit
+  
+  # @return [Hash] the options describing the Assembly
+  attr_accessor :options
+  
+  #
+  # Creates a new Assembly authenticated using the given +transloadit+
+  # instance.
+  #
+  # @param [Transloadit] transloadit the associated Transloadit instance
+  # @param [Hash]        options     the configuration for the Assembly;
+  #   see {Transloadit#assembly}
+  #
+  def initialize(transloadit, options = {})
+    self.transloadit = transloadit
+    self.options     = options
+  end
+  
+  #
+  # @return [Hash] the processing steps, formatted for sending to Transloadit
+  #
+  def steps
+    _wrap_steps_in_hash options[:steps]
+  end
+  
+  #
+  # Submits the assembly for processing. Accepts as many IO objects as you
+  # wish to process in the assembly. The last argument is an optional Hash
+  # of parameters to send along with the request.
+  #
+  # @overload submit!(*ios)
+  #   @param [Array<IO>] *ios   the files for the assembly to process
+  #
+  # @overload submit!(*ios, params = {})
+  #   @param [Array<IO>] *ios   the files for the assembly to process
+  #   @param [Hash]      params additional POST data to submit with the request
+  #
+  def submit!(*ios)
+    params = self.to_hash.update _extract_options!(*ios)
+    
+    ios.each_with_index do |f, i|
+      params.update "file_#{i}" => f
+    end
+    
+    request = Transloadit::Request.new '/assemblies',
+      self.transloadit.secret
+    
+    request.post(params).extend!(Transloadit::Response::Assembly)
+  end
+  
+  #
+  # @return [String] a human-readable version of the Assembly
+  #
+  def inspect
+    self.to_hash.inspect
+  end
+  
+  #
+  # @return [Hash] a Transloadit-compatible Hash of the Assembly's contents
+  #
+  def to_hash
+    self.options.merge(
+      :auth  => self.transloadit.to_hash,
+      :steps => self.steps
+    ).delete_if {|k,v| v.nil? }
+  end
+  
+  #
+  # @return [String] JSON-encoded String containing the Assembly's contents
+  #
+  def to_json
+    self.to_hash.to_json
+  end
+  
+  protected
+  
+  attr_writer :transloadit
+  
+  private
+  
+  #
+  # Returns a Transloadit-compatible Hash wrapping the +steps+ passed to it.
+  # Accepts any supported format the +steps+ could come in.
+  #
+  # @param  [nil, Hash, Step, Array] steps the steps to encode
+  # @return [Hash] the Transloadit-compatible hash of steps
+  #
+  def _wrap_steps_in_hash(steps)
+    case steps
+      when nil                then steps
+      when Hash               then steps
+      when Transloadit::Step  then steps.to_hash
+      else
+        steps.inject({}) {|h, s| h.update s }
+    end
+  end
+  
+  #
+  # Extracts the last argument from a set of arguments if it's a hash.
+  # Otherwise, returns an empty hash.
+  #
+  # @param  *args  the arguments to search for an options hash
+  # @return [Hash] the options passed, otherwise an empty hash
+  #
+  def _extract_options!(*args)
+    args.last.is_a?(Hash) ? args.pop : {}
+  end
+end

data/lib/transloadit/request.rb

@@ -0,0 +1,123 @@
+require 'transloadit'
+
+require 'rest-client'
+require 'openssl'
+
+#
+# Wraps requests to the Transloadit API. Ensures all API requests return a
+# parsed Transloadit::Response, and abstracts away finding a lightly-used
+# instance on startup.
+#
+class Transloadit::Request
+  # The default Transloadit API endpoint.
+  API_ENDPOINT = URI.parse('http://api2.transloadit.com/')
+  
+  # The default headers to send to the API.
+  API_HEADERS  = { 'User-Agent' => %{Transloadit Ruby SDK #{Transloadit::VERSION}} }
+  
+  # The HMAC algorithm used for calculation request signatures.
+  HMAC_ALGORITHM = OpenSSL::Digest::Digest.new('sha1')
+  
+  # @return [String] the API endpoint for the request
+  attr_reader   :url
+  
+  # @return [String] the authentication secret to sign the request with
+  attr_accessor :secret
+  
+  def self.bored!
+    self.api(self.bored)
+  end
+  
+  def initialize(url, secret = nil)
+    self.url    = URI.parse(url.to_s)
+    self.secret = secret
+  end
+  
+  def get(params = {})
+    self.request! do
+      self.api[url.path + self.to_query(params)].get(API_HEADERS)
+    end
+  end
+  
+  def delete(params = {})
+    self.request! do
+      self.api[url.path + self.to_query(params)].delete(API_HEADERS)
+    end
+  end
+  
+  def post(payload = {})
+    self.request! do
+      self.api[url.path].post(self.to_payload(payload), API_HEADERS)
+    end
+  end
+  
+  def inspect
+    self.url.to_s.inspect
+  end
+  
+  def to_hash
+    { :signature => self.signature }.delete_if {|k,v| v.nil? }
+  end
+  
+  def to_json
+    self.to_hash.to_json
+  end
+  
+  protected
+  
+  attr_writer :url
+  
+  def self.bored
+    self.new(API_ENDPOINT + '/instances/bored').get['api2_host']
+  end
+  
+  def self.api(uri = nil)
+    @api   = RestClient::Resource.new(uri) if uri
+    @api ||= RestClient::Resource.new(self.bored)
+  end
+  
+  def api
+    @api ||= begin
+      case self.url.host
+        when String then RestClient::Resource.new(self.url.host)
+        else self.class.api
+      end
+    end
+  end
+  
+  def to_payload(params = nil)
+    return self.to_hash if params.nil?
+    return self.to_hash if params.respond_to?(:empty?) and params.empty?
+    
+    self.to_hash.update(:params => params.to_json)
+  end
+  
+  def to_query(params = nil)
+    return '' if params.nil?
+    return '' if params.respond_to?(:empty?) and params.empty?
+    
+    escape = Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
+    params = URI.escape(params.to_json, escape)
+    
+    '?' + self.to_hash.
+      update(:params => params).
+      map {|k,v| "#{k}=#{v}" }.
+      join('&')
+  end
+  
+  def request!(&request)
+    Transloadit::Response.new request.call
+  rescue RestClient::Exception => e
+    Transloadit::Response.new e.response
+  end
+  
+  def signature
+    self.class._hmac(self.secret, self.params.to_json) if self.secret
+  end
+  
+  private
+  
+  def self._hmac(key, message)
+    OpenSSL::HMAC.hexdigest HMAC_ALGORITHM, key, message
+  end
+end

data/lib/transloadit/response.rb

@@ -0,0 +1,43 @@
+require 'transloadit'
+require 'delegate'
+
+class Transloadit::Response < Delegator
+  autoload :Assembly, 'transloadit/response/assembly'
+  
+  def initialize(response, &extension)
+    self.__setobj__(response)
+    
+    instance_eval(&extension) if block_given?
+  end
+  
+  def [](attribute)
+    self.body[attribute]
+  end
+  
+  def body
+    JSON.parse self.__getobj__.body
+  end
+  
+  def inspect
+    self.body.inspect
+  end
+  
+  def extend!(mod)
+    self.extend(mod)
+    self
+  end
+  
+  protected
+  
+  def __getobj__
+    @response
+  end
+  
+  def __setobj__(response)
+    @response = response
+  end
+  
+  def replace(other)
+    self.__setobj__ other.__getobj__
+  end
+end

data/lib/transloadit/response/assembly.rb

@@ -0,0 +1,15 @@
+require 'transloadit'
+
+module Transloadit::Response::Assembly
+  def reload!
+    self.replace Transloadit::Request.new(self['assembly_url']).get
+  end
+  
+  def cancel!
+    self.replace Transloadit::Request.new(self['assembly_url']).delete
+  end
+  
+  def completed?
+    r['ok'] == 'ASSEMBLY_COMPLETED'
+  end
+end

data/lib/transloadit/step.rb

@@ -0,0 +1,92 @@
+require 'transloadit'
+
+#
+# Implements the concept of a step in the Transloadit API. Each Step has a
+# +robot+ (e.g., '/image/resize' or '/video/thumbnail') and a hash of
+# +options+ specific to the chosen robot.
+#
+# See the Transloadit {documentation}[http://transloadit.com/docs/building-assembly-instructions]
+# for futher information on robot types and their parameters.
+#
+class Transloadit::Step
+  # @return [String] the robot to use
+  attr_reader :robot
+  
+  # @return [Hash] the robot's options
+  attr_accessor :options
+  
+  #
+  # Creates a new Step with the given +robot+.
+  #
+  # @param [String] robot   the robot to use
+  # @param [Hash]   options the configuration options for the robot; see
+  #   {Transloadit#step} for possible values
+  #
+  def initialize(robot, options = {})
+    self.robot   = robot
+    self.options = options
+  end
+  
+  #
+  # Automatically generates a unique, 32-character hex name for the step that
+  # uses this robot.
+  #
+  # @return [String] a randomly generated name
+  #
+  def name
+    # rand() is "good enough" for this; we generate 128 random bits (same
+    # length as a UUID for future compatibility) and convert it to hex
+    @name ||= rand(2 ** 128).to_s(16).rjust(32, '0')
+  end
+  
+  #
+  # Specifies that this Step should process the provided +input+ instead of
+  # the output of the Step before it.
+  #
+  # @param [Step, Array<Step>, Symbol, nil] input The input
+  #   step to use. Follows the conventions outlined in the
+  #   online  {documentation}[http://transloadit.com/docs/building-assembly-instructions#special-parameters].
+  #   The symbol +:original+ specifies that the original file should be sent
+  #   to the robot. A Step indicates that this Step's output should be used
+  #   as the input to this one. Likewise, an array of Steps tells Transloadit
+  #   to use pass each of their outputs to this Step. And lastly, an explicit
+  #   nil clears the setting and restores it to its default input.
+  #
+  # @return [String, Array<String>, nil> The value for the +:use+ parameter
+  #   that will actually be sent to the REST API.
+  #
+  def use(input)
+    self.options.delete(:use) and return if input.nil?
+    
+    self.options[:use] = case input
+      when Symbol then input.inspect
+      when Array  then input.map {|i| i.name }
+      else             [ input.name ]
+    end
+  end
+  
+  #
+  # @return [String] a human-readable version of the Step
+  #
+  def inspect
+    self.to_hash[self.name].inspect
+  end
+  
+  #
+  # @return [Hash] a Transloadit-compatible Hash of the Step's contents
+  #
+  def to_hash
+    { self.name => options.merge(:robot => self.robot) }
+  end
+  
+  #
+  # @return [String] JSON-encoded String containing the Step's hash contents
+  #
+  def to_json
+    self.to_hash.to_json
+  end
+  
+  protected
+  
+  attr_writer :robot
+end

data/lib/transloadit/version.rb

@@ -0,0 +1,4 @@
+class Transloadit
+  # The current version of Transloadit.
+  VERSION = '0.1.0'
+end

data/test/fixtures/cassettes/submit_assembly.yml

@@ -0,0 +1,67 @@
+--- 
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :get
+    uri: http://api2.transloadit.com:80/instances/bored
+    body: 
+    headers: 
+      accept: 
+      - "*/*; q=0.5, application/xml"
+      accept-encoding: 
+      - gzip, deflate
+      user-agent: 
+      - Transloadit Ruby SDK 0.0.1
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      access-control-allow-headers: 
+      - X-Requested-With, Content-Type, Accept, Content-Length
+      access-control-allow-methods: 
+      - POST, GET, PUT, DELETE, OPTIONS
+      access-control-allow-origin: 
+      - "*"
+      content-type: 
+      - text/plain
+      content-length: 
+      - "98"
+      connection: 
+      - keep-alive
+    body: "{\"ok\":\"BORED_INSTANCE_FOUND\",\"host\":\"vivian.transloadit.com\",\"api2_host\":\"vivian.transloadit.com\"}"
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://vivian.transloadit.com:80/assemblies
+    body: params=%7B%22steps%22%3A%7B%22a479db2c601661d8f914caf9cf258c0b%22%3A%7B%22robot%22%3A%22%2Fvideo%2Fthumbs%22%7D%7D%2C%22redirect_url%22%3A%22http%3A%2F%2Ffoo.bar%2F%22%2C%22auth%22%3A%7B%22key%22%3A%22%22%7D%2C%22file_0%22%3A%22%23%3CFile%3A0x00000100c63738%3E%22%7D
+    headers: 
+      accept: 
+      - "*/*; q=0.5, application/xml"
+      accept-encoding: 
+      - gzip, deflate
+      user-agent: 
+      - Transloadit Ruby SDK 0.0.1
+      content-length: 
+      - "298"
+      content-type: 
+      - application/x-www-form-urlencoded
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 302
+      message: Moved Temporarily
+    headers: 
+      content-type: 
+      - text/plain
+      access-control-allow-origin: 
+      - "*"
+      access-control-allow-methods: 
+      - POST, GET, PUT, DELETE, OPTIONS
+      access-control-allow-headers: 
+      - X-Requested-With, Content-Type, Accept, Content-Length
+      location: 
+      - http://foo.bar/?assembly_id=177c56e5435176f4877fbc1b397fa4f0&assembly_url=http://api2.vivian.transloadit.com/assemblies/177c56e5435176f4877fbc1b397fa4f0
+      transfer-encoding: 
+      - chunked
+    body: "{\"ok\":\"ASSEMBLY_COMPLETED\",\"message\":\"The assembly was successfully completed.\",\"assembly_id\":\"177c56e5435176f4877fbc1b397fa4f0\",\"assembly_url\":\"http://api2.vivian.transloadit.com/assemblies/177c56e5435176f4877fbc1b397fa4f0\",\"bytes_received\":298,\"bytes_expected\":298,\"client_agent\":\"Transloadit Ruby SDK 0.0.1\",\"client_ip\":\"69.180.12.41\",\"client_referer\":null,\"start_date\":\"2011/02/07 04:29:15 GMT\",\"upload_duration\":0.038,\"execution_duration\":0.002,\"fields\":{},\"uploads\":[],\"results\":{}}"
+    http_version: "1.1"

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+$:.unshift File.dirname(__FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'simplecov'
+
+SimpleCov.start { add_filter '/test/' }
+
+require 'minitest/autorun'
+require 'transloadit'
+require 'vcr'
+
+VCR.config do |c|
+  c.cassette_library_dir     = 'test/fixtures/cassettes'
+  c.default_cassette_options = { :record => :new_episodes }
+  c.stub_with :webmock
+end

data/test/unit/test_transloadit.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+describe Transloadit do
+  before do
+    @key    = 'a'
+    @secret = 'b'
+  end
+  
+  it 'must allow initialization' do
+    t = Transloadit.new(:key => @key, :secret => @secret)
+    t.must_be_kind_of Transloadit
+  end
+  
+  it 'must not be initialized with no arguments' do
+    lambda { Transloadit.new }.must_raise ArgumentError
+  end
+  
+  it 'must require a key' do
+    lambda { Transloadit.new(:secret => @secret) }.must_raise ArgumentError
+  end
+  
+  it 'must not require a secret' do
+    t = Transloadit.new(:key => @key)
+    t.must_be_kind_of Transloadit
+  end
+  
+  describe 'when initialized' do
+    before do
+      @transloadit = Transloadit.new(
+        :key    => @key,
+        :secret => @secret
+      )
+    end
+    
+    it 'must allow access to the key' do
+      @transloadit.key.must_equal @key
+    end
+    
+    it 'must allow access to the secret' do
+      @transloadit.secret.must_equal @secret
+    end
+    
+    it 'must create steps' do
+      step = @transloadit.step('/image/resize', :width => 320)
+
+      step.must_be_kind_of Transloadit::Step
+      step.robot.  must_equal '/image/resize'
+      step.options.must_equal :width => 320
+    end
+    
+    it 'must create assemblies' do                     
+      step     = @transloadit.step('')
+      assembly = @transloadit.assembly :steps => step
+      
+      assembly.must_be_kind_of Transloadit::Assembly
+      assembly.steps.must_equal step.to_hash
+    end
+    
+    it 'must create assemblies with multiple steps' do
+      steps = [
+        @transloadit.step(''),
+        @transloadit.step(''),
+      ]
+      
+      assembly = @transloadit.assembly :steps => steps
+      assembly.steps.must_equal steps.inject({}) {|h,s| h.merge s }
+    end
+    
+    it 'must inspect like a hash' do
+      @transloadit.inspect.must_equal @transloadit.to_hash.inspect
+    end
+    
+    it 'must produce Transloadit-compatible hash output' do
+      @transloadit.to_hash[:key]    .must_equal @key
+      @transloadit.to_hash[:expires].
+        must_match %r{\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}\+00:00}
+    end
+    
+    it 'must produce Transloadit-compatible JSON output' do
+      @transloadit.to_json.must_equal @transloadit.to_hash.to_json
+    end
+  end
+  
+  describe 'with no secret' do
+    before do
+      @transloadit = Transloadit.new(:key => @key)
+    end
+    
+    it 'must not include a secret in its hash output' do
+      @transloadit.to_hash.keys.wont_include :secret
+    end
+    
+    it 'must not include a secret in its JSON output' do
+      @transloadit.to_json.must_equal @transloadit.to_hash.to_json
+    end
+  end
+end

data/test/unit/transloadit/test_assembly.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+describe Transloadit::Assembly do
+  before do
+    @transloadit = Transloadit.new(:key => '')
+  end
+  
+  it 'must allow initialization' do
+    Transloadit::Assembly.new(@transloadit).
+      must_be_kind_of Transloadit::Assembly
+  end
+  
+  describe 'when initialized' do
+    before do    
+      @step     = @transloadit.step '/video/thumbs'
+      @redirect = 'http://foo.bar/'
+      
+      @assembly = Transloadit::Assembly.new @transloadit,
+        :steps        => @step,
+        :redirect_url => @redirect
+    end
+    
+    it 'must store a pointer to the transloadit instance' do
+      @assembly.transloadit.must_equal @transloadit
+    end
+    
+    it 'must remember the options passed' do
+      @assembly.options.must_equal(
+        :steps        => @step,
+        :redirect_url => @redirect
+      )
+    end
+    
+    it 'must wrap its step in a hash' do
+      @assembly.steps.must_equal @step.to_hash
+    end
+    
+    it 'must not wrap a nil step' do
+      @assembly.options[:steps] = nil
+      @assembly.steps.must_equal nil
+    end
+    
+    it 'must not wrap a hash step' do
+      @assembly.options[:steps] = { :foo => 1 }
+      @assembly.steps.must_equal :foo => 1
+    end
+    
+    it 'must inspect like a hash' do
+      @assembly.inspect.must_equal @assembly.to_hash.inspect
+    end
+    
+    it 'must produce Transloadit-compatible hash output' do
+      @assembly.to_hash.must_equal(
+        :auth         => @transloadit.to_hash,
+        :steps        => @assembly.steps,
+        :redirect_url => @redirect
+      )
+    end
+    
+    it 'must produce Transloadit-compatible JSON output' do
+      @assembly.to_json.must_equal @assembly.to_hash.to_json
+    end
+    
+    it 'must submit files for upload' do
+      VCR.use_cassette 'submit_assembly' do
+        response = @assembly.submit! open('lib/transloadit/version.rb')
+        response.code.must_equal 302
+        response.headers[:location].must_match %r{^http://foo.bar/}
+      end
+    end
+  end
+  
+  describe 'with multiple steps' do
+    before do
+      @encode = @transloadit.step '/video/encode'
+      @thumbs = @transloadit.step '/video/thumbs'
+      
+      @assembly = Transloadit::Assembly.new @transloadit,
+        :steps => [ @encode, @thumbs ]
+    end
+    
+    it 'must wrap its steps into one hash' do
+      @assembly.to_hash[:steps].keys.must_include @encode.name
+      @assembly.to_hash[:steps].keys.must_include @thumbs.name
+    end
+  end
+end

data/test/unit/transloadit/test_request.rb

@@ -0,0 +1,5 @@
+require 'test_helper'
+
+describe Transloadit::Request do
+  it 'should be tested'
+end

data/test/unit/transloadit/test_response.rb

@@ -0,0 +1,5 @@
+require 'test_helper'
+
+describe Transloadit::Response do
+  it 'should be tested'
+end

data/test/unit/transloadit/test_step.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+describe Transloadit::Step do
+  it 'must allow initialization' do
+    Transloadit::Step.new('/s3/store').must_be_kind_of Transloadit::Step
+  end
+  
+  describe 'when initialized' do
+    before do
+      @robot  = '/s3/store'
+      @key    = 'aws-access-key-id'
+      @secret = 'aws-secret-access-key'
+      @bucket = 's3-bucket-name'
+      
+      @step = Transloadit::Step.new '/s3/store',
+        :key    => @key,
+        :secret => @secret,
+        :bucket => @bucket
+    end
+    
+    it 'must generate a name' do
+      @step.name.wont_equal nil
+    end
+    
+    it 'must generate a unique name' do
+      @step.name.wont_equal Transloadit::Step.new('').name
+    end
+    
+    it 'must generate a name with 32 hex characters' do
+      @step.name.length.must_equal 32
+    end
+    
+    it 'must remember the type' do
+      @step.robot.must_equal @robot
+    end
+    
+    it 'must remember the parameters' do
+      @step.options.must_equal(
+        :key    => @key,
+        :secret => @secret,
+        :bucket => @bucket
+      )
+    end
+    
+    it 'must inspect like a hash' do
+      @step.inspect.must_equal @step.to_hash[@step.name].inspect
+    end
+    
+    it 'must produce Transloadit-compatible hash output' do
+      @step.to_hash.must_equal(
+        @step.name => {
+          :robot  => @robot,
+          :key    => @key,
+          :secret => @secret,
+          :bucket => @bucket
+        }
+      )
+    end
+    
+    it 'must produce Transloadit-compatible JSON output' do
+      @step.to_json.must_equal @step.to_hash.to_json
+    end
+  end
+  
+  describe 'when using alternative inputs' do
+    before do
+      @step = Transloadit::Step.new '/image/resize'
+    end
+    
+    it 'must allow using the original file as input' do
+      @step.use(:original).must_equal ':original'
+      @step.options[:use] .must_equal ':original'
+    end
+    
+    it 'must allow using another step' do
+      input = Transloadit::Step.new '/video/thumbnail'
+      
+      @step.use(input).   must_equal [ input.name ]
+      @step.options[:use].must_equal [ input.name ]
+    end
+    
+    it 'must allow using multiple steps' do
+      inputs = [
+        Transloadit::Step.new('/video/thumbnail'),
+        Transloadit::Step.new('/image/resize')
+      ]
+      
+      @step.use(inputs).  must_equal inputs.map {|i| i.name }
+      @step.options[:use].must_equal inputs.map {|i| i.name }
+    end
+    
+    it 'must allow using nothing' do
+      @step.use :original
+      @step.use(nil).must_equal nil
+      @step.options.keys.wont_include(:use)
+    end
+    
+    it 'must include the used steps in the hash output' do
+      @step.use(:original).           must_equal ':original'
+      @step.to_hash[@step.name][:use].must_equal ':original'
+    end
+  end
+end

data/transloadit.gemspec

@@ -0,0 +1,36 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+
+require 'transloadit/version'
+
+Gem::Specification.new do |gem|
+  gem.name     = 'transloadit'
+  gem.version  = Transloadit::VERSION
+  gem.platform = Gem::Platform::RUBY
+  
+  gem.authors  = %w{ Stephen Touset }
+  gem.email    = %w{ stephen@touset.org }
+  gem.homepage = 'http://github.com/stouset/transloadit/'
+  
+  gem.summary     = 'Official Ruby gem for Transloadit'
+  gem.description = 'The transloadit gem allows you to automate uploading files through the Transloadit REST API'
+  
+  gem.required_rubygems_version = '>= 1.3.6'
+  gem.rubyforge_project         = 'transloadit'
+  
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = %w{ lib }
+  
+  gem.add_dependency 'rest-client'
+  gem.add_dependency 'json'
+  
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'minitest' # needed for < 1.9.2
+  gem.add_development_dependency 'simplecov'
+  
+  gem.add_development_dependency 'vcr'
+  gem.add_development_dependency 'webmock'
+
+  gem.add_development_dependency 'yard'
+  gem.add_development_dependency 'rdiscount' # for YARD rdoc formatting
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification 
+name: transloadit
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Stephen
+- Touset
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-09 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  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: minitest
+  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: simplecov
+  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: vcr
+  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: yard
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: rdiscount
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id009
+description: The transloadit gem allows you to automate uploading files through the Transloadit REST API
+email: 
+- stephen@touset.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/transloadit.rb
+- lib/transloadit/assembly.rb
+- lib/transloadit/request.rb
+- lib/transloadit/response.rb
+- lib/transloadit/response/assembly.rb
+- lib/transloadit/step.rb
+- lib/transloadit/version.rb
+- test/fixtures/cassettes/submit_assembly.yml
+- test/test_helper.rb
+- test/unit/test_transloadit.rb
+- test/unit/transloadit/test_assembly.rb
+- test/unit/transloadit/test_request.rb
+- test/unit/transloadit/test_response.rb
+- test/unit/transloadit/test_step.rb
+- transloadit.gemspec
+has_rdoc: true
+homepage: http://github.com/stouset/transloadit/
+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: 1.3.6
+requirements: []
+
+rubyforge_project: transloadit
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Official Ruby gem for Transloadit
+test_files: 
+- test/fixtures/cassettes/submit_assembly.yml
+- test/test_helper.rb
+- test/unit/test_transloadit.rb
+- test/unit/transloadit/test_assembly.rb
+- test/unit/transloadit/test_request.rb
+- test/unit/transloadit/test_response.rb
+- test/unit/transloadit/test_step.rb