universal_s3_uploader 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ad4e7559307ef43646f64635419a558a23bf30ea
+  data.tar.gz: 8a1d368ad92187f46bd3002ab2680d06a331564d
+SHA512:
+  metadata.gz: a6ae6dcf83495dc7316c19edba7c0fbc8e6036ea5c9c98d0132c28e8a5b08a87488d0ba008c81a672df96a946da2713d764fff46a62c7e04dcd13f7072f8d82f
+  data.tar.gz: 0be4722c7c6727db0b818e6ffc2ccfc79d88ea57568be4e90ae39d766853f6e0550fa74d24e4526fc9f61288f6f72dba28029b47f9b04db4c9164cb442a33865

data/lib/universal_s3_uploader.rb

@@ -0,0 +1,92 @@
+require 'base64'
+require 'openssl'
+require 'digest/sha1'
+require 'action_view'
+require 'rails'
+
+module UniversalS3Uploader
+	module ViewHelper
+		def universal_s3_uploader_tag(key, policy_name, options = {})
+			uh = UploaderHelper.new(policy_name)
+
+			form_tag(uh.url, {method: 'POST', enctype: 'multipart/form-data', authenticity_token: false, class: 'universal_s3_uploader'}.merge(options)) do
+				uh.tags(key).html_safe
+			end
+		end
+
+		class UploaderHelper
+			def initialize(policy_name)
+				@config = YAML.load_file("#{Rails.root.to_s}/config/amazon.yml")
+				set_policy(policy_name)
+				set_bucket
+			end
+
+			# set expiration time
+			def set_policy(policy_name)
+				@policy = @config[policy_name]
+				@policy['conditions'] << ["starts-with", "$Filename", ""]	# for Flash upload
+				if @policy['expiration'] == '' || @policy['expiration'].nil?
+					@policy['expiration'] = 1.hour.from_now.iso8601
+				end
+			end
+
+			# extract bucket name
+			def set_bucket
+				@policy['conditions'].each do |condition|
+					if condition.class == Hash && condition.keys.first == 'bucket'
+						@bucket = condition.values.first
+						return
+					end
+				end
+
+				raise 'No bucket name in policy Exception'
+			end
+
+			def tags(key)
+				av = ActionView::Base.new
+				tag = ''
+
+				([{key: key}] + @policy['conditions']).each do |condition|
+					if condition.class == Hash
+						tag += av.hidden_field_tag condition.keys.first, condition.values.first, id: nil
+					elsif condition.class == Array
+						if condition[0] == 'eq' || condition[0] == 'starts-with'
+							tag += av.hidden_field_tag condition[1][1..-1], condition[2], id: nil unless condition[1] == '$key'
+						end
+					else
+						raise 'Something in policy unexpected'
+					end
+				end
+				tag += av.hidden_field_tag :AWSAccessKeyId, @config['access_key_id'], id: nil
+				tag += av.hidden_field_tag :Policy, policy_encoded, id: nil
+				tag += av.hidden_field_tag :Signature, signature, id: nil
+				tag += av.file_field_tag :file, multiple: true, accept: 'image/*'
+
+				tag += '<object id="swfUploader" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=11,1,0,0">'
+				tag += '<param name="movie" value="/assets/S3Uploader.swf">'
+				tag += '<param name="wmode" value="transparent">'
+				tag += '</object>'
+			end
+
+			def bucket
+				@bucket
+			end
+
+			def url
+				"http://#{@bucket}.s3.amazonaws.com"
+			end
+
+			def policy_encoded
+				Base64.encode64(@policy.to_json).gsub("\n","")
+			end
+
+			def signature
+				Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha1'), @config['secret_access_key'], policy_encoded)).gsub("\n","")
+			end
+		end
+	end
+end
+
+class ActionView::Base
+	include UniversalS3Uploader::ViewHelper
+end

data/vendor/assets/flash/S3Uploader.as

@@ -0,0 +1,120 @@
+package  
+{	
+	import flash.display.Sprite; 
+	import flash.events.MouseEvent;
+	import flash.net.FileReferenceList;
+	import flash.events.Event;
+	import flash.net.FileReference;
+	import flash.external.ExternalInterface;
+	import flash.net.URLVariables;
+	import flash.net.URLRequest;
+	import flash.net.URLRequestMethod;
+	import flash.net.FileFilter;
+	import flash.events.ProgressEvent;
+	import flash.display.Stage;
+	import flash.events.DataEvent;
+
+	public class S3Uploader extends Sprite
+	{
+		private var button;
+		private var files;
+		private var params;
+		
+		private function log(str:*):void
+		{
+			ExternalInterface.call("console.log", str);
+		}
+		
+		public function S3Uploader() 
+		{
+			getRequestData();
+			makeButton();
+		}
+		
+		private function getRequestData()
+		{
+			if (ExternalInterface.available)
+			{
+				params = new URLVariables();
+				ExternalInterface.addCallback("sendFormData", receiveFormData);
+			}
+		}
+		
+		private function receiveFormData(name:String, value:String):void
+		{
+			params[name] = value;
+		}
+		
+		private function makeButton():void
+		{
+			button = new Sprite();
+			button.graphics.beginFill(0x0000ff, 0);
+			button.graphics.drawRect(0,0,100,100);
+			button.graphics.endFill();
+			button.buttonMode = true;
+			button.addEventListener(MouseEvent.CLICK, clickHandler);
+			
+			addChild(button);
+		}
+		
+		private function clickHandler(evt:MouseEvent):void
+		{
+			files = new FileReferenceList();
+			files.addEventListener(Event.SELECT, selectHandler);
+			
+			var imageTypes:FileFilter = new FileFilter("Images (*.jpg, *.jpeg, *.gif, *.png)", "*.jpg; *.jpeg; *.gif; *.png"); 
+			files.browse(new Array(imageTypes));
+		}
+		
+		private function selectHandler(evt:Event):void
+		{
+			var index = 0;
+			for each (var file in files.fileList)
+			{
+				upload(file, index++);
+			}
+		}
+		
+		private function upload(file:FileReference, index:int):void
+		{
+			var request:URLRequest = new URLRequest('http://' + params["bucket"] + '.s3.amazonaws.com');
+			request.method = URLRequestMethod.POST;
+			request.data = params;
+			
+			function passIndex(func:Function):Function
+			{
+				return function handler(evt:Event):void { func(index, evt); }
+			}
+			
+			file.addEventListener(Event.OPEN, passIndex(openHandler));
+			file.addEventListener(ProgressEvent.PROGRESS, passIndex(progressHandler));
+			file.addEventListener(Event.COMPLETE, passIndex(completeHandler));
+			file.addEventListener(DataEvent.UPLOAD_COMPLETE_DATA, passIndex(uploadCompleteDataHandler));
+			
+			file.upload(request, 'file');
+		}
+		
+		private function openHandler(index:int, evt:Event):void
+		{
+			ExternalInterface.call("$('form.universal_s3_uploader').universal_s3_uploader().options.onLoadstart", index);
+		}
+		
+		private function progressHandler(index:int, evt:ProgressEvent):void
+		{
+			var event = new Object();
+			event.loaded = evt.bytesLoaded;
+			event.total = evt.bytesTotal;
+			ExternalInterface.call("$('form.universal_s3_uploader').universal_s3_uploader().options.onProgress", index, event);
+		}
+		
+		private function completeHandler(index:int, evt:Event):void
+		{
+			ExternalInterface.call("$('form.universal_s3_uploader').universal_s3_uploader().options.onSuccess", index);
+		}
+		
+		private function uploadCompleteDataHandler(index:int, evt:DataEvent):void
+		{
+			ExternalInterface.call("$('form.universal_s3_uploader').universal_s3_uploader().options.onResponse", evt.data);
+		}
+	}
+}

data/vendor/assets/javascripts/universal_s3_uploader.js

@@ -0,0 +1,128 @@
+(function($)
+{
+  $.fn.universal_s3_uploader = function(options)
+  {
+    if (this.length > 1)
+    {
+      this.each(function()
+      {
+        $(this).universal_s3_uploader(options);
+      });
+    }
+
+    if (!this.universalS3UploaderInstance)
+    {
+      this.universalS3UploaderInstance = new UniversalS3Uploader(this, options);
+    }
+
+    return this.universalS3UploaderInstance;
+  };
+
+  var defaultOptions =
+  {
+    onLoadstart: function(index, event)
+    {
+      console.log(index + " will be uploaded.");
+    },
+    onProgress: function(index, event)
+    {
+      var percentage = Math.round(event.loaded * 100 / event.total);
+      console.log(percentage + " %");
+    },
+    onSuccess: function(index, event)
+    {
+      console.log(index + " was successfully uploaded.");
+    },
+    onResponse: function(response)
+    {
+      console.log(response);
+    }
+  };
+
+  var supportFormData = window.FormData;
+
+  UniversalS3Uploader = (function()
+  {
+    function UniversalS3Uploader(element, options)
+    {
+      this.element = $(element);
+      this.options = $.extend({}, defaultOptions, options);
+
+      this.init();
+    }
+
+    UniversalS3Uploader.prototype.init = function()
+    {
+      this.element.children('div').remove();
+
+      if (supportFormData)  // if supports HTML5 FormData
+      {
+        this.element.children('object#swfUploader').remove();
+
+        this.element.children('input[type=file]').change(function()
+        {
+          $(this).parent().trigger('submit');
+          $(this).replaceWith($(this).clone(true));
+        });
+
+        this.element.submit($.proxy(this.submit, this));
+      }
+
+      else  // use Flash uploader
+      {
+        var flashObject = this.element.children('object').get(0);
+
+        var fileField = this.element.children('input[type=file]');
+
+        $(flashObject).css("height", fileField.height()+10 + "px").css("width", fileField.width() + "px");
+        $(flashObject).css("position", "relative").css("left", "-" + fileField.width() + "px").css("top", "6px");
+
+        this.element.children('input[type=hidden]').each(function()
+        {
+          flashObject.sendFormData(this.name, this.value);
+        });
+      }
+    };
+
+    UniversalS3Uploader.prototype.submit = function()
+    {
+      var files = this.element.children('input[type=file]').get(0).files || [this.element.children('input[type=file]').val()];
+      for (var i = 0, len = files.length; i < len; i++) this.upload(files[i], i);
+
+      return false;
+    };
+
+    UniversalS3Uploader.prototype.upload = function(file, index)
+    {
+      var fd = new FormData();
+      this.element.children('input[type=hidden]').each(function()
+      {
+        fd.append(this.name, this.value);
+      });
+      fd.append('file', file);
+
+      function passIndex(func)
+      {
+        return function(event) { $.proxy(func, this)(index, event); }
+      }
+
+      var onResponse = this.options.onResponse;
+      function callResponseHandler(event)
+      {
+        onResponse(this.response);
+      }
+
+      var xhr = new XMLHttpRequest();
+
+      xhr.addEventListener("loadstart", passIndex(this.options.onLoadstart), false);
+      xhr.upload.addEventListener("progress", passIndex(this.options.onProgress), false);
+      xhr.addEventListener("load", passIndex(this.options.onSuccess), false);
+      xhr.addEventListener("load", callResponseHandler, false);
+
+      xhr.open('POST', this.element.attr('action'), true);
+      xhr.send(fd);
+    };
+
+    return UniversalS3Uploader;
+  })();
+})(jQuery);

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: universal_s3_uploader
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Dohan Kim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-05 00:00:00.000000000 Z
+dependencies: []
+description: This library helps you to upload files to the Amazon S3 Server with AJAX
+  techniques in almost of browser environments such as IE, FF and Chrome.
+email:
+- hodoli2776@kaist.ac.kr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/universal_s3_uploader.rb
+- vendor/assets/flash/S3Uploader.as
+- vendor/assets/flash/S3Uploader.fla
+- vendor/assets/flash/S3Uploader.swf
+- vendor/assets/javascripts/universal_s3_uploader.js
+homepage: http://rubygems.org/gems/universal_s3_uploader
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: the AJAX S3 Uploader working in Cross Browser
+test_files: []