vertical-s3_swf_upload 0.3.2.1

data/lib/s3_swf_upload/signature.rb

@@ -0,0 +1,203 @@
+module S3SwfUpload
+  module Signature
+    $hexcase = false  # hex output format. false - lowercase; true - uppercase
+    $b64pad  = "=" # base-64 pad character. "=" for strict RFC compliance
+    $chrsz   = 8  # bits per input character. 8 - ASCII; 16 - Unicode    
+
+    def hex_sha1(s)
+      return binb2hex(core_sha1(str2binb(s), s.length * $chrsz))
+    end
+
+    def b64_hmac_sha1(key, data)
+      return binb2b64(core_hmac_sha1(key, data))
+    end
+
+    # Absolute barebones "unit" tests
+    def assert(expr)
+      raise 'Assertion failed' unless (expr)
+    end
+
+    def self_test
+      num, cnt = [1732584193, 5]
+
+      assert(core_sha1(str2binb('abc'), 'abc'.length) == [-519653305, -1566383753, -2070791546, -753729183, -204968198])
+      assert(rol(num, cnt) == -391880660)
+      assert(safe_add(2042729798, num) == -519653305)
+      assert((num.js_shl(cnt)) == -391880672)
+      assert((num.js_shr_zf(32 - cnt)) == 12)
+      assert(sha1_ft(0, -271733879, -1732584194, 271733878) == -1732584194)
+      assert(sha1_kt(0) == 1518500249)
+      assert(safe_add(safe_add(rol(num, cnt), sha1_ft(0, -271733879, -1732584194, 271733878)), safe_add(safe_add(-1009589776, 1902273280), sha1_kt(0))) == 286718899)
+      assert(str2binb('foo bar hey there') == [1718578976, 1650553376, 1751480608, 1952998770, 1694498816])
+      assert(hex_sha1("abc") == "a9993e364706816aba3e25717850c26c9cd0d89d")
+      assert(b64_hmac_sha1("foo", "abc") == "frFXMR9cNoJdsSPnjebZpBhUKzI=")
+    end
+
+    # Calculate the SHA-1 of an array of big-endian words, and a bit length
+    def core_sha1(x, len)
+      # append padding
+      x[len >> 5] ||= 0
+      x[len >> 5] |= 0x80 << (24 - len % 32)
+      x[((len + 64 >> 9) << 4) + 15] = len
+
+      w = Array.new(80, 0)
+      a =  1732584193
+      b = -271733879
+      c = -1732584194
+      d =  271733878
+      e = -1009589776
+
+      #for(var i = 0; i < x.length; i += 16)
+      i = 0
+      while(i < x.length)
+        olda = a
+        oldb = b
+        oldc = c
+        oldd = d
+        olde = e
+
+        #for(var j = 0; j < 80; j++)
+        j = 0
+        while(j < 80)
+          if(j < 16) 
+            w[j] = x[i + j] || 0
+          else 
+            w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1)
+          end
+
+          t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
+                       safe_add(safe_add(e, w[j]), sha1_kt(j)))
+          e = d
+          d = c
+          c = rol(b, 30)
+          b = a
+          a = t
+          j += 1
+        end
+
+        a = safe_add(a, olda)
+        b = safe_add(b, oldb)
+        c = safe_add(c, oldc)
+        d = safe_add(d, oldd)
+        e = safe_add(e, olde)
+        i += 16
+      end
+      return [a, b, c, d, e]
+    end
+
+    # Perform the appropriate triplet combination function for the current
+    # iteration
+    def sha1_ft(t, b, c, d)
+      return (b & c) | ((~b) & d) if(t < 20) 
+      return b ^ c ^ d if(t < 40)
+      return (b & c) | (b & d) | (c & d) if(t < 60)
+      return b ^ c ^ d;
+    end
+
+    # Determine the appropriate additive constant for the current iteration
+    def sha1_kt(t)
+      return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
+             (t < 60) ? -1894007588 : -899497514
+    end
+
+    # Calculate the HMAC-SHA1 of a key and some data
+    def core_hmac_sha1(key, data)
+      bkey = str2binb(key)
+      if(bkey.length > 16) 
+        bkey = core_sha1(bkey, key.length * $chrsz)
+      end
+
+      ipad = Array.new(16, 0)
+      opad = Array.new(16, 0)
+      #for(var i = 0; i < 16; i++)
+      i = 0
+      while(i < 16)
+        ipad[i] = (bkey[i] || 0) ^ 0x36363636
+        opad[i] = (bkey[i] || 0) ^ 0x5C5C5C5C
+        i += 1
+      end
+
+      hash = core_sha1((ipad + str2binb(data)), 512 + data.length * $chrsz)
+      return core_sha1((opad + hash), 512 + 160)
+    end
+
+    # Add integers, wrapping at 2^32. This uses 16-bit operations internally
+    # to work around bugs in some JS interpreters.
+    def safe_add(x, y)
+      v = (x+y) % (2**32)
+      return v > 2**31 ? v- 2**32 : v
+    end
+
+    # Bitwise rotate a 32-bit number to the left.
+    def rol(num, cnt)
+      #return (num << cnt) | (num >>> (32 - cnt))
+      return (num.js_shl(cnt)) | (num.js_shr_zf(32 - cnt))
+    end
+
+    # Convert an 8-bit or 16-bit string to an array of big-endian words
+    # In 8-bit function, characters >255 have their hi-byte silently ignored.
+    def str2binb(str)
+      bin = []
+      mask = (1 << $chrsz) - 1
+      #for(var i = 0; i < str.length * $chrsz; i += $chrsz)
+      i = 0
+      while(i < str.length * $chrsz)
+        bin[i>>5] ||= 0
+        bin[i>>5] |= (str[i / $chrsz].ord & mask) << (32 - $chrsz - i%32)
+        i += $chrsz
+      end
+      return bin
+    end
+
+    # Convert an array of big-endian words to a string
+    #   function binb2str(bin)
+    # {
+    #   var str = "";
+    #   var mask = (1 << $chrsz) - 1;
+    #   for(var i = 0; i < bin.length * 32; i += $chrsz)
+    #     str += String.fromCharCode((bin[i>>5] >>> (32 - $chrsz - i%32)) & mask);
+    #   return str;
+    # }
+    # 
+
+    # Convert an array of big-endian words to a hex string.
+    def binb2hex(binarray)
+      hex_tab = $hexcase ? "0123456789ABCDEF" : "0123456789abcdef"
+      str = ""
+      #for(var i = 0; i < binarray.length * 4; i++)
+      i = 0
+      while(i < binarray.length * 4)
+        str += hex_tab[(binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF].chr +
+               hex_tab[(binarray[i>>2] >> ((3 - i%4)*8  )) & 0xF].chr
+        i += 1
+      end
+      return str;
+    end
+
+    # Convert an array of big-endian words to a base-64 string
+    def binb2b64(binarray)
+      tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+      str = ""
+
+      #for(var i = 0; i < binarray.length * 4; i += 3)
+      i = 0
+      while(i < binarray.length * 4)
+        triplet = (((binarray[i   >> 2].to_i >> 8 * (3 -  i   %4)) & 0xFF) << 16) |
+                     (((binarray[i+1 >> 2].to_i >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 ) |
+                      ((binarray[i+2 >> 2].to_i >> 8 * (3 - (i+2)%4)) & 0xFF)
+        #for(var j = 0; j < 4; j++)
+        j = 0
+        while(j < 4)
+          if(i * 8 + j * 6 > binarray.length * 32)
+            str += $b64pad
+          else
+            str += tab[(triplet >> 6*(3-j)) & 0x3F].chr
+          end
+          j += 1
+        end
+        i += 3
+      end
+      return str
+    end
+  end
+end

data/lib/s3_swf_upload/view_helpers.rb

@@ -0,0 +1,173 @@
+module S3SwfUpload
+  module ViewHelpers
+    def s3_swf_upload_tag(options = {})
+      buttonWidth             = options[:buttonWidth]  || 100
+      buttonHeight            = options[:buttonHeight] || 30
+    	flashVersion            = options[:height] || '9.0.0'
+    	queueSizeLimit          = options[:queueSizeLimit] || 100
+    	fileSizeLimit           = options[:fileSizeLimit] || 524288000
+      fileTypes               = options[:fileTypes] || '*.*'
+      fileTypeDescs           = options[:fileTypeDescs] || 'All Files'
+      selectMultipleFiles     = options.has_key?(:selectMultipleFiles) ? options[:selectMultipleFiles] : true
+      keyPrefix               = options[:keyPrefix] || ''
+    	signaturePath           = options[:signaturePath] || '/s3_uploads.xml'
+      swfFilePath             = options[:swfFilePath] || '/flash/s3_upload.swf'
+    	buttonUpPath            = options[:buttonUpPath] || '/flash/s3_up_button.gif'
+    	buttonOverPath          = options[:buttonOverPath] || '/flash/s3_over_button.gif'
+    	buttonDownPath          = options[:buttonDownPath] || '/flash/s3_down_button.gif'
+    	                                 
+    	onFileAdd							  = options[:onFileAdd] || false		
+    	onFileRemove						= options[:onFileRemove] || false
+    	onFileSizeLimitReached 	= options[:onFileSizeLimitReached] || false	
+    	onFileNotInQueue				= options[:onFileNotInQueue] || false	
+    	                                 
+    	onQueueChange						= options[:onQueueChange] || false
+    	onQueueClear						= options[:onQueueClear] || false
+    	onQueueSizeLimitReached	= options[:onQueueSizeLimitReached] || false
+    	onQueueEmpty						= options[:onQueueEmpty] || false
+    	                                 
+    	onUploadingStop					= options[:onUploadingStop] || false
+    	onUploadingStart				= options[:onUploadingStart] || false
+    	onUploadingFinish				= options[:onUploadingFinish] || false
+    	                                 
+    	onSignatureOpen					= options[:onSignatureOpen] || false
+    	onSignatureProgress			= options[:onSignatureProgress] || false
+    	onSignatureHttpStatus		= options[:onSignatureHttpStatus] || false
+    	onSignatureComplete			= options[:onSignatureComplete] || false
+    	onSignatureSecurityError= options[:onSignatureSecurityError] || false
+    	onSignatureIOError			= options[:onSignatureIOError] || false
+    	onSignatureXMLError			= options[:onSignatureXMLError] || false
+    	                                 
+    	onUploadOpen						= options[:onUploadOpen] || false
+    	onUploadProgress				= options[:onUploadProgress] || false
+    	onUploadHttpStatus			= options[:onUploadHttpStatus] || false
+    	onUploadComplete				= options[:onUploadComplete] || false
+    	onUploadIOError					= options[:onUploadIOError] || false
+    	onUploadSecurityError		= options[:onUploadSecurityError] || false
+    	onUploadError						= options[:onUploadError] || false
+    	
+      @include_s3_upload ||= false 
+      @count ||= 1
+      
+      out = ''
+
+      if Rails.version < '3.1.0'
+        if !@include_s3_upload
+          out << javascript_include_tag('s3_upload')
+          @include_s3_upload = true
+        end
+      end
+
+      out << "\n<script type=\"text/javascript\">\n"
+      out << "var s3_swf_#{@count}_object = s3_swf_init('s3_swf_#{@count}', {\n"
+      out << "buttonWidth: #{buttonWidth},\n" if buttonWidth
+      out << "buttonHeight: #{buttonHeight},\n" if buttonHeight
+      out << "flashVersion: '#{flashVersion}',\n" if flashVersion
+      out << "queueSizeLimit: #{queueSizeLimit},\n" if queueSizeLimit
+      out << "fileSizeLimit: #{fileSizeLimit},\n" if fileSizeLimit
+      out << "fileTypes: '#{fileTypes}',\n" if fileTypes
+      out << "fileTypeDescs: '#{fileTypeDescs}',\n" if fileTypeDescs
+      out << "selectMultipleFiles: #{selectMultipleFiles.to_s},\n"
+      out << "keyPrefix: '#{keyPrefix}',\n" if keyPrefix
+      out << "signaturePath: '#{signaturePath}',\n" if signaturePath
+      out << "swfFilePath: '#{swfFilePath}',\n" if swfFilePath
+      out << "buttonUpPath: '#{buttonUpPath}',\n" if buttonUpPath
+      out << "buttonOverPath: '#{buttonOverPath}',\n" if buttonOverPath
+      out << "buttonDownPath: '#{buttonDownPath}',\n" if buttonDownPath
+      out << "swfVarObj: 's3_swf_#{@count}_object',\n"
+       
+      out << %(onFileAdd: function(file){
+                #{onFileAdd}
+              },) if onFileAdd
+      out << %(onFileRemove: function(file){
+                #{onFileRemove}
+              },) if onFileRemove
+      out << %(onFileSizeLimitReached: function(file){
+                #{onFileSizeLimitReached}
+              },) if onFileSizeLimitReached
+      out << %(onFileNotInQueue: function(file){
+                #{onFileNotInQueue}
+              },) if onFileNotInQueue
+              
+      out << %(onQueueChange: function(queue){
+                #{onQueueChange}
+              },) if onQueueChange
+      out << %(onQueueSizeLimitReached: function(queue){
+                #{onQueueSizeLimitReached}
+              },) if onQueueSizeLimitReached
+      out << %(onQueueEmpty: function(queue){
+                #{onQueueEmpty}
+              },) if onQueueEmpty
+      out << %(onQueueClear: function(queue){
+                #{onQueueClear}
+              },) if onQueueClear
+              
+      out << %(onUploadingStart: function(){
+                #{onUploadingStart}
+              },) if onUploadingStart
+      out << %(onUploadingStop: function(){
+                #{onUploadingStop}
+              },) if onUploadingStop
+      out << %(onUploadingFinish: function(){
+                #{onUploadingFinish}
+              },) if onUploadingFinish
+              
+      out << %(onSignatureOpen: function(file,event){
+                #{onSignatureOpen}
+              },) if onSignatureOpen
+      out << %(onSignatureProgress: function(file,progress_event){
+                #{onSignatureProgress}
+              },) if onSignatureProgress
+      out << %(onSignatureSecurityError: function(file,security_error_event){
+                #{onSignatureSecurityError}
+              },) if onSignatureSecurityError
+      out << %(onSignatureComplete: function(file,event){
+                #{onSignatureComplete}
+              },) if onSignatureComplete
+      out << %(onSignatureIOError: function(file,io_error_event){
+                #{onSignatureIOError}
+              },) if onSignatureIOError
+      out << %(onSignatureHttpStatus: function(file,http_status_event){
+                #{onSignatureHttpStatus}
+              },) if onSignatureHttpStatus
+      out << %(onSignatureXMLError: function(file,error_message){
+                #{onSignatureXMLError}
+              },) if onSignatureXMLError
+              
+      out << %(onUploadError: function(upload_options,error){
+                #{onUploadError}
+              },) if onUploadError
+      out << %(onUploadOpen: function(upload_options,event){
+                #{onUploadOpen}
+              },) if onUploadOpen
+      out << %(onUploadProgress: function(upload_options,progress_event){
+                #{onUploadProgress}
+              },) if onUploadProgress
+      out << %(onUploadIOError: function(upload_options,io_error_event){
+                #{onUploadIOError}
+              },) if onUploadIOError
+      out << %(onUploadHttpStatus: function(upload_options,http_status_event){
+                #{onUploadHttpStatus}
+              },) if onUploadHttpStatus
+      out << %(onUploadSecurityError: function(upload_options,security_error_event){
+                #{onUploadSecurityError}
+              },) if onUploadSecurityError
+      out << %(onUploadComplete: function(upload_options,event){
+                #{onUploadComplete}
+              },) if onUploadComplete
+      # This closes out the object (no comma)
+      out << "foo: 'bar'"              
+      out << "});\n"
+      out << "</script>\n"
+      out << "<div id=\"s3_swf_#{@count}\">\n"
+      out << "Please <a href=\"http://www.adobe.com/go/getflashplayer\">Update</a> your Flash Player to Flash v#{flashVersion} or higher...\n"
+      out << "</div>\n"
+      
+      @count += 1
+      out
+    end
+
+  end
+end
+
+ActionView::Base.send(:include, S3SwfUpload::ViewHelpers)

data/s3_swf_upload.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name              = "vertical-s3_swf_upload"
+  s.rubyforge_project = "s3_swf_upload"
+  s.version           = "0.3.2.1"
+  s.rubygems_version  = "1.3.6"
+  s.date              = "2010-11-16"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors       = ["Nathan Colgate"]
+  s.email         = "nathan@brandnewbox.com"
+  s.homepage      = "https://github.com/nathancolgate/s3-swf-upload-plugin"
+  s.description   = "Rails 3 gem that allows you to upload files directly to S3 from your application using flex for file management, css for presentation, and javascript for behavior."
+  s.summary       = "Rails 3 gem that allows you to upload files directly to S3 from your application using flex for file management, css for presentation, and javascript for behavior."
+
+  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.rdoc_options  = ["--line-numbers", "--inline-source", "--title", "S3_swf_upload", "--main", "README.textile"]
+  s.require_paths = ["lib"]
+
+  if s.respond_to? :specification_version
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    # if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0')
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: vertical-s3_swf_upload
+version: !ruby/object:Gem::Version
+  version: 0.3.2.1
+  prerelease: 
+platform: ruby
+authors:
+- Nathan Colgate
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2010-11-16 00:00:00.000000000 Z
+dependencies: []
+description: Rails 3 gem that allows you to upload files directly to S3 from your
+  application using flex for file management, css for presentation, and javascript
+  for behavior.
+email: nathan@brandnewbox.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG
+- Gemfile
+- MIT-LICENSE
+- Manifest
+- README.textile
+- Rakefile
+- flex_src/bin-release/flex-config.xml
+- flex_src/compile
+- flex_src/src/Globals.as
+- flex_src/src/S3Uploader.as
+- flex_src/src/com/adobe/net/MimeTypeMap.as
+- flex_src/src/com/elctech/S3UploadOptions.as
+- flex_src/src/com/elctech/S3UploadRequest.as
+- flex_src/src/com/nathancolgate/s3_swf_upload/BrowseButton.as
+- flex_src/src/com/nathancolgate/s3_swf_upload/S3Queue.as
+- flex_src/src/com/nathancolgate/s3_swf_upload/S3Signature.as
+- flex_src/src/com/nathancolgate/s3_swf_upload/S3Upload.as
+- lib/patch/integer.rb
+- lib/s3_swf_upload.rb
+- lib/s3_swf_upload/railtie.rb
+- lib/s3_swf_upload/railties/generators/s3_swf_upload.rb
+- lib/s3_swf_upload/railties/generators/uploader/USAGE
+- lib/s3_swf_upload/railties/generators/uploader/templates/amazon_s3.yml
+- lib/s3_swf_upload/railties/generators/uploader/templates/s3_down_button.gif
+- lib/s3_swf_upload/railties/generators/uploader/templates/s3_over_button.gif
+- lib/s3_swf_upload/railties/generators/uploader/templates/s3_up_button.gif
+- lib/s3_swf_upload/railties/generators/uploader/templates/s3_upload.js
+- lib/s3_swf_upload/railties/generators/uploader/templates/s3_upload.swf
+- lib/s3_swf_upload/railties/generators/uploader/templates/s3_uploads_controller.rb
+- lib/s3_swf_upload/railties/generators/uploader/uploader_generator.rb
+- lib/s3_swf_upload/railties/tasks/crossdomain.xml
+- lib/s3_swf_upload/s3_config.rb
+- lib/s3_swf_upload/signature.rb
+- lib/s3_swf_upload/view_helpers.rb
+- s3_swf_upload.gemspec
+homepage: https://github.com/nathancolgate/s3-swf-upload-plugin
+licenses: []
+post_install_message: 
+rdoc_options:
+- --line-numbers
+- --inline-source
+- --title
+- S3_swf_upload
+- --main
+- README.textile
+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.2'
+requirements: []
+rubyforge_project: s3_swf_upload
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Rails 3 gem that allows you to upload files directly to S3 from your application
+  using flex for file management, css for presentation, and javascript for behavior.
+test_files: []
+has_rdoc: