directwave 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.1
+
+* initial release

data/Gemfile

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

data/LICENCE

@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright © 2012 radiant.fm
+
+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.md

@@ -0,0 +1,318 @@
+# DirectWave
+
+This gem provides a simple way to direct upload big files to Amazon S3 
+storage from Ruby applications and process it with cloud encoding service, 
+such as zencoder.com or pandastream.com.
+
+It works well with Rack based web applications, such as Ruby on Rails.
+
+Inspired by [CarrierWave](http://github.com/jnicklas/DirectWave) and used in [radiant.fm](http://radiant.fm)
+
+## Information
+
+* RDoc documentation [available on RubyDoc.info](http://rubydoc.info/gems/DirectWave/frames)
+* Source code [available on GitHub](https://github.com/radiantfm/directwave)
+
+## Getting Help
+
+* Please report bugs on the [issue tracker]https://github.com/radiantfm/directwave/issues).
+
+## Installation
+
+Install the latest stable release:
+
+	[sudo] gem install directwave
+
+In Rails, add it to your Gemfile:
+
+``` ruby
+gem 'directwave'
+```
+
+## Getting Started
+
+Start off by generating an uploader:
+
+	rails generate directwave Audio
+
+this should give you a file in:
+
+	app/uploaders/audio_uploader.rb
+
+Now you can customize your uploader. It
+should look something like this:
+
+``` ruby
+class AudioUploader < DirectWave::Uploader::Base
+end
+```
+
+Most of the time you are going to want to use DirectWave together with an ORM.
+It is quite simple to mount uploaders on columns in your model, so you can
+simply assign files and get going:
+
+## ActiveRecord
+
+Add a string column to the model you want to mount the uploader on:
+
+``` ruby
+add_column :tracks, :audio, :string
+```
+
+Open your model file and mount the uploader:
+
+``` ruby
+class Track < ActiveRecord::Base
+  mount_directwave :audio, AudioUploader
+end
+```
+
+Now you can cache files by assigning them to the attribute, they will
+automatically be stored when the record is saved.
+
+``` ruby
+u = Track.new(:audio_from_key => params[:key])
+u.save!
+u.audio.url # => '/url/to/file.png'
+```
+
+## Rails
+
+You can use different flash uploaders for multiple direct upload, 
+such as [Uploadify](http://sd.r). For example in Rails with CoffeeScript and Nokogiri
+generate uploader controller at first:
+
+	rails g controller Uploads new create
+
+and add following code:
+
+``` ruby
+class UploadsController < ApplicationController
+  def new
+    @uploader = Track.new.audio
+  end
+
+  def create
+    xml_doc  = Nokogiri::XML(params[:xml])
+
+    @track = Track.new(audio_from_key: xml_doc.xpath('//Key').text)
+    @track.save
+    
+    head :ok
+  end
+end
+```
+
+when in `assets/javascript/uploads.js.coffe` insert:
+
+``` html
+$(document).ready ->
+  uploader = $("#uploadify") 
+  uploader.uploadify {
+    uploader     : "path/to/swf/uploader"
+    method       : "post"
+    multi        : true
+    auto         : true
+    fileDataName : "file"
+    script       : uploader.data("bucket) + ".s3.amazonaws.com"
+    scriptAccess : "always"
+    scriptData   : {
+      "AWSAccessKeyId" : uploader.data("aws-access-key-id"),
+      "key"            : uploader.data("key"),
+      "acl"            : uploader.data("acl"),
+      "policy"         : uploader.data("policy"),
+      "signature"      : uploader.data("signature"),
+      "success_action_status" : "201"
+    },
+    onError    : (event, id, file, error) -> console.log(error),
+    onComplete : (event, id, file, response, data) -> 
+      $.ajax({
+        type  : 'post',
+        url   : '/uploads',
+        data  : { xml: response },
+        cache : false
+      });
+  }
+```   
+
+in `views/uploads/new.html.erb`:
+
+``` html
+<%= file_field_tag "uploadify" , "data-aws-access-key-id" => @uploader.s3_access_key_id, 
+                                 "data-key"       => @uploader.store_key, 
+                                 "data-acl"       => @uploader.s3_acl, 
+                                 "data-policy"    => @uploader.s3_policy,
+                                 "data-signature" => @uploader.s3_signature,
+                                 "data-bucker"    => @uploader.s3_bucket %> 
+```
+
+
+## Changing the directories
+
+In order to change where uploaded files are stored, just override the `store_dir`
+method:
+
+``` ruby
+class MyUploader < DirectWave::Uploader::Base
+  def store_dir
+    '/my/upload/directory'
+  end
+end
+```
+
+If you want change where files will be uploaded, override the `upload_dir`
+method:
+
+``` ruby
+class MyUploader < DirectWave::Uploader::Base
+  def store_dir
+    '/my/upload/directory/tmp'
+  end
+end
+```
+
+## Adding versions
+
+Often you'll want to add different versions of the same file.
+There is built in support for this:
+
+``` ruby
+class Audio < DirectWave::Uploader::Base
+  version :aac do
+    def filename
+      # where @name name of version, for now "aac"
+      @filename ||= [extract(:guid), [@name, extract(:basename)].join("/") << ".aac"].join("/")
+    end
+
+    def process
+      # proccessing code goes here
+      # always call super at the begin
+      super
+      
+      job = Zencoder::Job.create(
+        { 
+          input: "s3://#{@uploader.s3_bucket}.s3.amazonaws.com/#{@uploader.versions[:original].key}", 
+          outputs: [
+            {
+              label: "aac",
+              url: "s3://#{@uploader.s3_bucket}.s3.amazonaws.com/#{@uploader.versions[:aac].key}",
+              format: "aac",
+              notifications: [
+                { url: "http://zencoderfetcher/", format: "json" }
+              ]
+            } # aac
+          ] # outputs
+        }
+      ) 
+      @uploader.model.job_id = job.body["id"]
+    end
+  end
+end
+```
+
+When this uploader is used, a version called aac is then created, which is processed with `process`. 
+The uploader could be used like this:
+
+``` ruby
+uploader.url # => '/url/to/original/file.png'               
+uploader.url(:original) # => '/url/to/original/file.png'               
+uploader.aac.url # => '/url/to/aac/file.png'   
+uploader.url(:aac) # => '/url/to/aac/file.png'   
+```
+
+You can also override `global_process` method wich called after 
+all process within versions:
+
+``` ruby
+class Audio < DirectWave::Uploader::Base
+  version :aac
+  version :wav
+
+  def global_process
+    super
+    
+    job = Zencoder::Job.create(
+      { 
+        input: "s3://#{s3_bucket}.s3.amazonaws.com/#{versions[:original].key}", 
+        outputs: [
+          {
+            label: "aac",
+            url: "s3://#{s3_bucket}.s3.amazonaws.com/#{versions[:aac].key}",
+            format: "aac",
+            notifications: [
+              { url: "http://zencoderfetcher/", format: :json }
+            ]
+          }, # aac
+          {
+            label: "wav",
+            url: "s3://#{s3_bucket}.s3.amazonaws.com/#{versions[:wav].key}",
+            format: "wav",
+            notifications: [
+              { url: "http://zencoderfetcher/", format: :json }
+            ]
+          } # wav
+
+        ] # outputs
+      }
+    ) 
+    model.job_id = job.body["id"]
+  end
+end
+```
+
+## Providing a default URL
+
+In many cases  it might be a good idea to rovide a default url, a fallback in case 
+no file has been uploaded. You can do this easily by overriding the `default_url` 
+method in your uploader:
+
+``` ruby
+class Audio < DirectWave::Uploader::Base
+  def default_url
+    "/fallback/default.mp3"
+  end
+end
+```
+
+## Configuring DirectWave
+
+DirectWave has a broad range of configuration options, which you can configure,
+both globally and on a per-uploader basis:
+
+``` ruby
+DirectWave.configure do |config|
+  config.s3_access_key_id     = "access_key_id"
+  config.s3_secret_access_key = "secret_access_key"
+  config.s3_bucket            = "bucket"
+  config.s3_region            = "region"
+  config.s3_access_policy     = :private # or other valid value, see amazon s3 docs
+end
+```
+If you're using Rails, create an initializer for this:
+
+``` ruby
+config/initializers/directwave.rb
+```
+
+## License
+
+Copyright (c) 2012 radiant.fm
+
+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/Rakefile

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+require 'rubygems'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color]
+end
+
+task :default => [:spec]

data/directwave.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "directwave/version"
+
+Gem::Specification.new do |s|
+  s.name        = "directwave"
+  s.version     = Directwave::VERSION
+  s.authors     = ["Dima Kochnev"]
+  s.email       = ["kochnev.d@gmail.com"]
+  s.homepage    = "http://radiant.fm"
+  s.summary     = %q{Ruby direct uploader to Amazon S3}
+  s.description = %q{A simple way to direct upload big files to Amazon S3 storage from Ruby applications and process it with cloud encoding service.}
+  s.extra_rdoc_files = ["README.md"]
+
+  s.rubyforge_project = "directwave"
+
+  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_dependency "activesupport", ["~> 3.1"]
+  s.add_dependency "uuid"
+  s.add_dependency "aws-sdk"
+
+  s.add_development_dependency "rails", ["~> 3.1"]
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "sqlite3"
+end

data/lib/directwave/mounter.rb

@@ -0,0 +1,95 @@
+module DirectWave
+  
+  ##
+  # If a Class is extended with this module, it gains the mount_uploader
+  # method, which is used for mapping attributes to uploaders and allowing
+  # easy assignment.
+  #
+  # You can use mount_uploader with pretty much any class, however it is
+  # intended to be used with some kind of persistent storage, like an ORM.
+  #
+  module Mounter
+    
+    ##
+    # === Returns
+    #
+    # [Hash{Symbol => DirectWave}] what uploaders are mounted on which columns
+    #
+
+    def uploaders
+      @uploaders ||= {}
+      @uploaders = superclass.uploaders.merge(@uploaders) if superclass.respond_to?(:uploaders)
+      @uploaders
+    end
+    
+    ##
+    # Mounts the given uploader on the given column. This means that assigning
+    # and reading from the column will upload and retrieve files. Supposing
+    # that a Track class has an uploader mounted on audio, you can assign and
+    # retrieve files like this:
+    #
+    #     @track.store_key = "s3/key/of/file"
+    #     @track.audio # => <Uploader>
+    #
+    #     @user.audio.url # => "url/to/original/version.aac"
+    #
+    # Passing a block makes it possible to customize the uploader. This can be
+    # convenient for brevity, but if there is any significatnt logic in the
+    # uploader, you should do the right thing and have it in its own file.
+    #
+    # === Added instance methods
+    #
+    # Supposing a class has used +mount_uploader+ to mount an uploader on a column
+    # named +image+, in that case the following methods will be added to the class:
+    #
+    # [audio]                   Returns an instance of the uploader only if anything has been uploaded
+    #
+    # === Parameters
+    #
+    # [column (Symbol)]                   the attribute to mount this uploader on
+    # [uploader (DirectWave::Uploader)]  the uploader class to mount
+    # [&block (Proc)]                     customize anonymous uploaders
+    #
+    # === Examples
+    #
+    # Mounting uploaders on different columns.
+    #
+    #     class Track
+    #       mount_directwave :audio, AudioUploader
+    #       mount_directwave :lyrics, LyricsUploader
+    #     end
+    #
+    # This will add an anonymous uploader with only the default settings:
+    #
+    #     class Data
+    #       mount_uploader :csv
+    #     end
+    #
+    # this will add an anonymous uploader overriding the upload_dir and store_dir:
+    #
+    #     class Track
+    #       mount_uploader :audio do
+    #         def upload_dir
+    #           "audio"
+    #         end
+    #
+    #         def store_dir
+    #           "audio"
+    #         end
+    #       end
+    #     end
+    #
+
+    def mount_directwave(column, uploader=nil)
+      uploader = Class.new(uploader || DirectWave::Uploader::Base)
+      uploaders[column.to_sym] = uploader
+      
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{column}
+          @uploader ||= self.class.uploaders[:#{column}].new(self, :#{column})
+        end
+      RUBY
+    end
+
+  end # Mounter
+end # DirectWave

data/lib/directwave/orm/activerecord.rb

@@ -0,0 +1,49 @@
+require 'active_record'
+
+module DirectWave
+  module ActiveRecord
+    
+    include DirectWave::Mounter
+    
+    ##
+    # See +DirectWave::Mounter#mount_uploader+ for documentation
+    #
+    # === Added instance methods
+    #
+    # Supposing a class has used +mount_uploader+ to mount an uploader on a column
+    # named +image+, in that case the following methods will be added to the class:
+    #
+    # [#{column}_from_key]      Returns the key of assigned file 
+    # [#{column}_from_key=]     Assign file from S3 key 
+    #
+    
+    def mount_directwave(column, uploader=nil)
+      super
+
+      instance_eval <<-RUBY, __FILE__, __LINE__+1
+      RUBY
+      
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        attr_accessible :#{column}_from_key
+        
+        def #{column}_from_key
+          send(:#{column}).store_key
+        end
+
+        def #{column}_from_key=(string)
+          send(:#{column}).store_key = string
+        end
+      
+        before_save do
+          send(:#{column}).save
+        end
+        
+        after_destroy do
+          send(:#{column}).destroy
+        end
+      RUBY
+    end
+  end # ActiveRecord
+end # DirectWave
+
+ActiveRecord::Base.extend DirectWave::ActiveRecord

data/lib/directwave/railtie.rb

@@ -0,0 +1,9 @@
+module DirectWave
+  class Railtie < Rails::Railtie
+    initializer "directwave.active_record" do
+      ActiveSupport.on_load :active_record do
+        require "directwave/orm/activerecord"
+      end
+    end
+  end
+end # DirectWave

data/lib/directwave/uploader/accreditation.rb

@@ -0,0 +1,63 @@
+module DirectWave
+  
+  module Uploader 
+    module Accreditation
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        ##
+        # === Returns
+        #
+        # [String] Amazon S3 acl
+        #
+        def s3_acl
+          @s3_acl ||= s3_access_policy.to_s.gsub("_", "-")
+        end
+
+        ##
+        # === Returns
+        #
+        # [Boolean] Amazon S3 policy
+        #
+        def s3_policy
+          @s3_policy ||= Base64.encode64(
+            {
+              "expiration" => expiration_date,
+              "conditions" => [
+                {"bucket" => s3_bucket},
+                ["starts-with", "$key", upload_dir],
+                {"success_action_status" => "201"},
+                ["starts-with", "$filename", ""],
+                ["starts-with", "$folder", ""],
+                {"acl" => s3_acl},
+                ["content-length-range", 1, max_file_size]
+              ]
+            }.to_json
+          ).gsub("\n","")
+        end
+        
+        ##
+        # === Returns
+        #
+        # [Boolean] Amazon S3 signature
+        #
+        def s3_signature
+          @s3_signature ||= Base64.encode64(
+            OpenSSL::HMAC.digest(
+              OpenSSL::Digest::Digest.new("sha1"), 
+              s3_secret_access_key, s3_policy
+            )
+          ).gsub("\n","")
+        end  
+      end # InstanceMethods
+      
+      private
+      
+      def guid
+        UUID.generate
+      end
+
+    end # Accreditation
+  end # Uploader
+
+end # DirectWave

data/lib/directwave/uploader/configuration.rb

@@ -0,0 +1,68 @@
+module DirectWave
+  
+  module Uploader
+    module Configuration
+      extend ActiveSupport::Concern
+      
+      included do
+        add_config :s3_access_policy
+        add_config :s3_bucket
+        add_config :s3_access_key_id
+        add_config :s3_secret_access_key
+        add_config :s3_region
+        add_config :s3_authentication_timeout
+        
+        add_config :max_file_size
+        add_config :expiration_date
+        
+        add_config :store_dir
+        add_config :upload_dir
+
+        reset_config
+      end
+      
+      module ClassMethods
+        def add_config(name)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            class << self
+              def #{name}(value=nil)
+                @#{name} = value if value
+                return @#{name} if self.object_id == #{self.object_id} || defined?(@#{name})
+                name = superclass.#{name}
+                return nil if name.nil? && !instance_variable_defined?("@#{name}")
+                @#{name} = name && !name.is_a?(Module) && !name.is_a?(Symbol) && !name.is_a?(Numeric) && !name.is_a?(TrueClass) && !name.is_a?(FalseClass) ? name.dup : name
+              end
+              
+              def #{name}=(value)
+                @#{name} = value
+              end
+            end 
+            
+            def #{name}
+              self.class.#{name}
+            end
+          RUBY
+        end
+        
+        def configure
+          yield self
+        end
+
+        def reset_config
+          configure do |config|
+            config.s3_access_policy = :public_read
+            config.s3_region        = "us-east-1"
+            config.s3_authentication_timeout = 60.minutes
+            
+            config.max_file_size   = 300.megabytes
+            config.expiration_date = 6.hours.from_now.utc.iso8601
+
+            config.store_dir = "uploads"
+            config.upload_dir = "uploads/tmp"
+          end
+        end
+      end # ClassMethods
+    end #Configuration
+  end # Uploader
+  
+end # DirectWave