inline_uploader 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Matt Freels
+
+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.rdoc

@@ -0,0 +1,18 @@
+= inline_uploader
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Matt Freels. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "inline_uploader"
+    gem.summary = %Q{rack endpoint and handler for ajax uploads}
+    gem.description = %Q{Provides an upload endpoint for ajax uploads and easy attachement of ajax uploads as POST params for normal requests.}
+    gem.email = "matt@freels.name"
+    gem.homepage = "http://github.com/freels/inline_uploader"
+    gem.authors = ["Matt Freels"]
+    #gem.add_development_dependency "thoughtbot-shoulda"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+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 :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "inline_uploader #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/uploader/public/ajaxfileupload.js

@@ -0,0 +1,201 @@
+
+jQuery.extend({
+	
+
+    createUploadIframe: function(id, uri)
+	{
+			//create frame
+            var frameId = 'jUploadFrame' + id;
+            
+            if(window.ActiveXObject) {
+                var io = document.createElement('<iframe id="' + frameId + '" name="' + frameId + '" />');
+                if(typeof uri== 'boolean'){
+                    io.src = 'javascript:false';
+                }
+                else if(typeof uri== 'string'){
+                    io.src = uri;
+                }
+            }
+            else {
+                var io = document.createElement('iframe');
+                io.id = frameId;
+                io.name = frameId;
+            }
+            io.style.position = 'absolute';
+            io.style.top = '-1000px';
+            io.style.left = '-1000px';
+
+            document.body.appendChild(io);
+
+            return io			
+    },
+    createUploadForm: function(id, fileElementId)
+	{
+		//create form	
+		var formId = 'jUploadForm' + id;
+		var fileId = 'jUploadFile' + id;
+		var form = $('<form  action="" method="POST" name="' + formId + '" id="' + formId + '" enctype="multipart/form-data"></form>');	
+		var oldElement = $('#' + fileElementId);
+		var newElement = $(oldElement).clone();
+		$(oldElement).attr('id', fileId);
+		$(oldElement).before(newElement);
+		$(oldElement).appendTo(form);
+		//set attributes
+		$(form).css('position', 'absolute');
+		$(form).css('top', '-1200px');
+		$(form).css('left', '-1200px');
+		$(form).appendTo('body');		
+		return form;
+    },
+
+    ajaxFileUpload: function(s) {
+        // TODO introduce global settings, allowing the client to modify them for all requests, not only timeout		
+        s = jQuery.extend({}, jQuery.ajaxSettings, s);
+        var id = new Date().getTime()        
+		var form = jQuery.createUploadForm(id, s.fileElementId);
+		var io = jQuery.createUploadIframe(id, s.secureuri);
+		var frameId = 'jUploadFrame' + id;
+		var formId = 'jUploadForm' + id;		
+        // Watch for a new set of requests
+        if ( s.global && ! jQuery.active++ )
+		{
+			jQuery.event.trigger( "ajaxStart" );
+		}            
+        var requestDone = false;
+        // Create the request object
+        var xml = {}   
+        if ( s.global )
+            jQuery.event.trigger("ajaxSend", [xml, s]);
+        // Wait for a response to come back
+        var uploadCallback = function(isTimeout)
+		{			
+			var io = document.getElementById(frameId);
+            try 
+			{				
+				if(io.contentWindow)
+				{
+					 xml.responseText = io.contentWindow.document.body?io.contentWindow.document.body.innerHTML:null;
+                	 xml.responseXML = io.contentWindow.document.XMLDocument?io.contentWindow.document.XMLDocument:io.contentWindow.document;
+					 
+				}else if(io.contentDocument)
+				{
+					 xml.responseText = io.contentDocument.document.body?io.contentDocument.document.body.innerHTML:null;
+                	xml.responseXML = io.contentDocument.document.XMLDocument?io.contentDocument.document.XMLDocument:io.contentDocument.document;
+				}						
+            }catch(e)
+			{
+				jQuery.handleError(s, xml, null, e);
+			}
+            if ( xml || isTimeout == "timeout") 
+			{				
+                requestDone = true;
+                var status;
+                try {
+                    status = isTimeout != "timeout" ? "success" : "error";
+                    // Make sure that the request was successful or notmodified
+                    if ( status != "error" )
+					{
+                        // process the data (runs the xml through httpData regardless of callback)
+                        var data = jQuery.uploadHttpData( xml, s.dataType );    
+                        // If a local callback was specified, fire it and pass it the data
+                        if ( s.success )
+                            s.success( data, status );
+    
+                        // Fire the global callback
+                        if( s.global )
+                            jQuery.event.trigger( "ajaxSuccess", [xml, s] );
+                    } else
+                        jQuery.handleError(s, xml, status);
+                } catch(e) 
+				{
+                    status = "error";
+                    jQuery.handleError(s, xml, status, e);
+                }
+
+                // The request was completed
+                if( s.global )
+                    jQuery.event.trigger( "ajaxComplete", [xml, s] );
+
+                // Handle the global AJAX counter
+                if ( s.global && ! --jQuery.active )
+                    jQuery.event.trigger( "ajaxStop" );
+
+                // Process result
+                if ( s.complete )
+                    s.complete(xml, status);
+
+                jQuery(io).unbind()
+
+                setTimeout(function()
+									{	try 
+										{
+											$(io).remove();
+											$(form).remove();	
+											
+										} catch(e) 
+										{
+											jQuery.handleError(s, xml, null, e);
+										}									
+
+									}, 100)
+
+                xml = null
+
+            }
+        }
+        // Timeout checker
+        if ( s.timeout > 0 ) 
+		{
+            setTimeout(function(){
+                // Check to see if the request is still happening
+                if( !requestDone ) uploadCallback( "timeout" );
+            }, s.timeout);
+        }
+        try 
+		{
+           // var io = $('#' + frameId);
+			var form = $('#' + formId);
+			$(form).attr('action', s.url);
+			$(form).attr('method', 'POST');
+			$(form).attr('target', frameId);
+            if(form.encoding)
+			{
+                form.encoding = 'multipart/form-data';				
+            }
+            else
+			{				
+                form.enctype = 'multipart/form-data';
+            }			
+            $(form).submit();
+
+        } catch(e) 
+		{			
+            jQuery.handleError(s, xml, null, e);
+        }
+        if(window.attachEvent){
+            document.getElementById(frameId).attachEvent('onload', uploadCallback);
+        }
+        else{
+            document.getElementById(frameId).addEventListener('load', uploadCallback, false);
+        } 		
+        return {abort: function () {}};	
+
+    },
+
+    uploadHttpData: function( r, type ) {
+        var data = !type;
+        data = type == "xml" || data ? r.responseXML : r.responseText;
+        // If the type is "script", eval it in global context
+        if ( type == "script" )
+            jQuery.globalEval( data );
+        // Get the JavaScript object, if JSON is used.
+        if ( type == "json" )
+            eval( "data = " + data );
+        // evaluate scripts within html
+        if ( type == "html" )
+            jQuery("<div>").html(data).evalScripts();
+			//alert($('param', data).each(function(){alert($(this).attr('value'));}));
+        return data;
+    }
+})
+

data/examples/uploader/uploader.rb

@@ -0,0 +1,77 @@
+require 'rubygems'
+require 'sinatra'
+require 'inline_uploader'
+require 'fileutils'
+
+save_dir = File.join(Dir.pwd, 'public/uploads')
+FileUtils.mkdir_p save_dir
+
+# teh app
+
+set :port, 3000
+enable :show_exceptions
+
+use InlineUploader
+
+helpers do
+  include InlineUploader::Helpers
+end
+
+get '/' do
+  entries = Dir[File.join(save_dir, '*')]
+  haml :index, :locals => {:entries => entries}
+end
+
+post '/save_upload' do
+  upload = params[:upload]
+  path   = File.join(save_dir, File.basename(upload[:filename]))
+  FileUtils.move(upload[:tempfile].path, path)
+
+  redirect '/'
+end
+
+template :index do
+  <<-end_haml
+!!! Strict
+%html
+  %head
+    %script(type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js")
+    %script(type="text/javascript" src="/ajaxfileupload.js")
+    :javascript
+      $(function(){
+        $('#submit_upload').click(function(){
+          $.ajaxFileUpload({
+            url : '/inline_upload',
+            fileElementId : 'upload_field',
+            success : function(){
+              $('#upload_container').text('File uploaded.');
+            }
+          });
+
+          $('#upload_container').text('Uploading...');
+
+          return false;
+        });
+      });
+
+  %body
+    %h1 uploads
+    %ul
+      - entries.each do |entry|
+        %li= entry
+
+    %h2 Add something new:
+
+    %form(method="POST" action="/save_upload")
+      %input(type="hidden" name="has_inline_uploads" value="1")
+      %input(type="hidden" name="upload" value="\#{inline_upload_tag}")
+
+      %div#upload_container
+        %input(type="file" id="upload_field" name="\#{inline_upload_tag}")
+        %a#submit_upload(href="#") upload file
+
+      %div
+        %input(type="submit" value="Save")
+  end_haml
+end
+

data/inline_uploader.gemspec

@@ -0,0 +1,53 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{inline_uploader}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Matt Freels"]
+  s.date = %q{2009-10-10}
+  s.description = %q{Provides an upload endpoint for ajax uploads and easy attachement of ajax uploads as POST params for normal requests.}
+  s.email = %q{matt@freels.name}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "examples/uploader/public/ajaxfileupload.js",
+     "examples/uploader/uploader.rb",
+     "inline_uploader.gemspec",
+     "lib/inline_uploader.rb",
+     "test/inline_uploader_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/freels/inline_uploader}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{rack endpoint and handler for ajax uploads}
+  s.test_files = [
+    "test/inline_uploader_test.rb",
+     "test/test_helper.rb",
+     "examples/uploader/uploader.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/inline_uploader.rb

@@ -0,0 +1,186 @@
+require 'digest/md5'
+require 'fileutils'
+require 'tmpdir'
+require 'logger'
+require 'yaml'
+
+class InlineUploader
+
+  # 32 is the length of an md5 hex digest
+  TAG_PREFIX = 'inline_upload_'.freeze
+  TAG_REGEXP = /\A#{TAG_PREFIX}[a-z0-9]{32,32}\Z/i.freeze
+  TAG_LENGTH = TAG_PREFIX.length + 32
+
+  DEFAULT_ENDPOINT    = '/inline_upload'
+  DEFAULT_UPLOAD_FLAG = 'has_inline_uploads'
+
+  def self.new(inner_app, options = {})
+    uploader = allocate
+    uploader.send :initialize, options
+
+    Rack::Builder.app do
+      map uploader.endpoint do
+        run InlineUploader::EndPoint.new(uploader)
+      end
+
+      map '/' do
+        use InlineUploader::Attacher, uploader
+        run inner_app
+      end
+    end
+  end
+
+  attr_reader :upload_dir, :endpoint, :flag_param, :logger
+
+  def initialize(options)
+    @upload_dir = options[:tmp_dir]     || File.join(Dir.tmpdir, "inline_uploader_#{Process.pid}#{Time.now.to_i}")
+    @flag_param = options[:upload_flag] || DEFAULT_UPLOAD_FLAG
+    @endpoint   = options[:endpoint]    || DEFAULT_ENDPOINT
+    @logger     = options[:logger]      || Logger.new($stderr)
+
+    FileUtils.mkdir_p(upload_dir)
+  end
+
+  class Attacher
+    def initialize(app, delegate)
+      @delegate = delegate
+      @app      = app
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      # we have to look at both get and post as if Rack::Request.params 
+      # has been called, GET will also contain all POST params. go figure.
+      attach_previous_uploads request.GET, request.POST do
+        return @app.call(env)
+      end
+    end
+
+    def attach_previous_uploads(*hashes)
+      return yield unless hashes.inject(false) {|others,h| !h.delete(@delegate.flag_param).nil? or others }
+
+      logger.info "Attaching Inline Upload Tags."
+      fds = {}
+
+      begin
+        hashes.each {|h| fds.merge! attach_fds(h) }
+
+        yield
+
+      ensure
+        fds.values.each do |f|
+          f.close unless f.closed?
+          FileUtils.rm(f.path) if File.exist?(f.path)
+        end
+      end
+    end
+
+    def attach_fds(params)
+      params.inject({}) do |fds, kv|
+        key, val = kv
+
+        if val.is_a? Hash
+          fds.merge! attach_fds(params[key])
+
+        elsif tag = get_valid_tag(val)
+          upload = File.join(@delegate.upload_dir, tag)
+
+          if File.exist?(upload)
+            file            = YAML.load_file("#{upload}_meta")
+            file[:name]     = key
+            file[:tempfile] = File.open(upload, 'rb')
+
+            params[key] = file
+            fds[tag]    = file[:tempfile]
+
+            logger.info "attaching upload file at #{upload}"
+          else
+            params[key] = nil
+
+            logger.info "no upload file found at #{upload}"
+          end
+        end
+
+        fds
+      end
+    end
+
+    # returns a valid tag or nil.
+    def get_valid_tag(val)
+      val if val.is_a? String and val.length == TAG_LENGTH and val =~ TAG_REGEXP
+    end
+
+    def logger
+      @delegate.logger
+    end
+  end
+
+  class EndPoint
+    HEADERS     = {'Content-Type' => 'text/plain'}
+    SUCCESS     = [200, HEADERS, ['success']]
+    BAD_REQUEST = [400, HEADERS, ['bad request']]
+    ERROR       = [500, HEADERS, ['error']]
+
+    class BadRequestError < StandardError; end
+
+    def initialize(delegate)
+      @delegate = delegate
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      raise BadRequestError unless valid_request? request
+
+      tag = request.params.keys.detect {|k| valid_tag? k }
+      raise BadRequestError unless tag
+
+      file = request.params[tag]
+      raise BadRequestError unless file.member?(:tempfile)
+
+      p request.params
+
+      upload = File.join(@delegate.upload_dir, tag)
+
+      FileUtils.mkdir_p @delegate.upload_dir
+      FileUtils.move file[:tempfile].path, upload
+
+      File.open("#{upload}_meta", 'w') do |f|
+        file.delete(:tempfile)
+        f.puts file.to_yaml
+      end
+
+      SUCCESS
+    rescue BadRequestError
+      BAD_REQUEST
+    rescue Exception => e
+      logger.error e.inspect
+      logger.error e.backtrace.join("\n")
+      ERROR
+    end
+
+    private
+
+    def valid_request?(req)
+      req.post? and req.content_type =~ %r|multipart/form-data|
+    end
+
+    def valid_tag?(tag)
+      tag.is_a? String and tag.length == TAG_LENGTH and tag =~ TAG_REGEXP
+    end
+
+    def logger
+      @delegate.logger
+    end
+  end
+
+  module Helpers
+    def inline_upload_tag(label = :default)
+      @inline_upload_tags ||= {}
+      @inline_upload_tags[label] ||= begin
+        hsh = Digest::MD5.hexdigest("I like turtles! #{rand} #{Time.now.to_f}")
+        "#{TAG_PREFIX}#{hsh}"
+      end
+    end
+  end
+end

data/test/inline_uploader_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class InlineUploaderTest < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'inline_uploader'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: inline_uploader
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matt Freels
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-10 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Provides an upload endpoint for ajax uploads and easy attachement of ajax uploads as POST params for normal requests.
+email: matt@freels.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- examples/uploader/public/ajaxfileupload.js
+- examples/uploader/uploader.rb
+- inline_uploader.gemspec
+- lib/inline_uploader.rb
+- test/inline_uploader_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/freels/inline_uploader
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: rack endpoint and handler for ajax uploads
+test_files: 
+- test/inline_uploader_test.rb
+- test/test_helper.rb
+- examples/uploader/uploader.rb