dotimeout-rails 1.0.0.0.1.0

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gem "rails", "3.1.1"
+
+gem "jquery-rails"

data/README.md

@@ -0,0 +1,26 @@
+<pre>
+     _     _____ _                            _                 _ _     
+  __| | __|_   _(_)_ __ ___   ___  ___  _   _| |_     _ __ __ _(_) |___ 
+ / _` |/ _ \| | | | '_ ` _ \ / _ \/ _ \| | | | __|   | '__/ _` | | / __|
+| (_| | (_) | | | | | | | | |  __/ (_) | |_| | |_    | | | (_| | | \__ \
+ \__,_|\___/|_| |_|_| |_| |_|\___|\___/ \__,_|\__|___|_|  \__,_|_|_|___/
+                                                |_____|
+</pre>
+
+This is a gemified version of Ben Alman's jQuery doTimeout plugin. See http://benalman.com/projects/jquery-dotimeout-plugin for more details.
+
+[![Build Status](https://secure.travis-ci.org/harrigan/dotimeout-rails.png)](http://travis-ci.org/harrigan/dotimeout-rails)
+
+## Instructions
+
+Add the following to your Gemfile:
+`gem "dotimeout-rails"`
+
+Then add the following to your application.js manifest:
+`//= require dotimeout`
+
+Don't forget to run `bundle update` after upgrading to the latest gem version to ensure it's used by your Rails app.
+
+## License
+
+jQuery doTimeout is dual licensed under the MIT and GPL licenses: http://benalman.com/about/license

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+
+task :default do
+end

data/dotimeout-rails.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dotimeout-rails/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dotimeout-rails"
+  s.version     = DotTimeoutRails::VERSION
+  s.authors     = ["Martin Harrigan"]
+  s.email       = ["martinharrigan@gmail.com"]
+  s.homepage    = "http://github.com/harrigan/dotimeout-rails"
+  s.summary     = %q{A gemified version of Ben Alman's jQuery doTimeout plugin.}
+  s.description = %q{A gemified version of Ben Alman's jQuery doTimeout plugin.}
+
+  s.rubyforge_project = "dotimeout-rails"
+
+  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"]
+end

data/lib/dotimeout-rails.rb

@@ -0,0 +1 @@
+require "dotimeout-rails/engine" if defined?(Rails && Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR >=1)

data/lib/dotimeout-rails/engine.rb

@@ -0,0 +1,6 @@
+module DotTimeoutRails
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/dotimeout-rails/version.rb

@@ -0,0 +1,3 @@
+module DotTimeoutRails
+  VERSION = "1.0.0.0.1.0"
+end

data/vendor/assets/javascripts/dotimeout.jquery.js

@@ -0,0 +1,285 @@
+/*!
+ * jQuery doTimeout: Like setTimeout, but better! - v1.0 - 3/3/2010
+ * http://benalman.com/projects/jquery-dotimeout-plugin/
+ * 
+ * Copyright (c) 2010 "Cowboy" Ben Alman
+ * Dual licensed under the MIT and GPL licenses.
+ * http://benalman.com/about/license/
+ */
+
+// Script: jQuery doTimeout: Like setTimeout, but better!
+//
+// *Version: 1.0, Last updated: 3/3/2010*
+// 
+// Project Home - http://benalman.com/projects/jquery-dotimeout-plugin/
+// GitHub       - http://github.com/cowboy/jquery-dotimeout/
+// Source       - http://github.com/cowboy/jquery-dotimeout/raw/master/jquery.ba-dotimeout.js
+// (Minified)   - http://github.com/cowboy/jquery-dotimeout/raw/master/jquery.ba-dotimeout.min.js (1.0kb)
+// 
+// About: License
+// 
+// Copyright (c) 2010 "Cowboy" Ben Alman,
+// Dual licensed under the MIT and GPL licenses.
+// http://benalman.com/about/license/
+// 
+// About: Examples
+// 
+// These working examples, complete with fully commented code, illustrate a few
+// ways in which this plugin can be used.
+// 
+// Debouncing      - http://benalman.com/code/projects/jquery-dotimeout/examples/debouncing/
+// Delays, Polling - http://benalman.com/code/projects/jquery-dotimeout/examples/delay-poll/
+// Hover Intent    - http://benalman.com/code/projects/jquery-dotimeout/examples/hoverintent/
+// 
+// About: Support and Testing
+// 
+// Information about what version or versions of jQuery this plugin has been
+// tested with, what browsers it has been tested in, and where the unit tests
+// reside (so you can test it yourself).
+// 
+// jQuery Versions - 1.3.2, 1.4.2
+// Browsers Tested - Internet Explorer 6-8, Firefox 2-3.6, Safari 3-4, Chrome 4-5, Opera 9.6-10.1.
+// Unit Tests      - http://benalman.com/code/projects/jquery-dotimeout/unit/
+// 
+// About: Release History
+// 
+// 1.0 - (3/3/2010) Callback can now be a string, in which case it will call
+//       the appropriate $.method or $.fn.method, depending on where .doTimeout
+//       was called. Callback must now return `true` (not just a truthy value)
+//       to poll.
+// 0.4 - (7/15/2009) Made the "id" argument optional, some other minor tweaks
+// 0.3 - (6/25/2009) Initial release
+
+(function($){
+  '$:nomunge'; // Used by YUI compressor.
+  
+  var cache = {},
+    
+    // Reused internal string.
+    doTimeout = 'doTimeout',
+    
+    // A convenient shortcut.
+    aps = Array.prototype.slice;
+  
+  // Method: jQuery.doTimeout
+  // 
+  // Initialize, cancel, or force execution of a callback after a delay.
+  // 
+  // If delay and callback are specified, a doTimeout is initialized. The
+  // callback will execute, asynchronously, after the delay. If an id is
+  // specified, this doTimeout will override and cancel any existing doTimeout
+  // with the same id. Any additional arguments will be passed into callback
+  // when it is executed.
+  // 
+  // If the callback returns true, the doTimeout loop will execute again, after
+  // the delay, creating a polling loop until the callback returns a non-true
+  // value.
+  // 
+  // Note that if an id is not passed as the first argument, this doTimeout will
+  // NOT be able to be manually canceled or forced. (for debouncing, be sure to
+  // specify an id).
+  // 
+  // If id is specified, but delay and callback are not, the doTimeout will be
+  // canceled without executing the callback. If force_mode is specified, the
+  // callback will be executed, synchronously, but will only be allowed to
+  // continue a polling loop if force_mode is true (provided the callback
+  // returns true, of course). If force_mode is false, no polling loop will
+  // continue, even if the callback returns true.
+  // 
+  // Usage:
+  // 
+  // > jQuery.doTimeout( [ id, ] delay, callback [, arg ... ] );
+  // > jQuery.doTimeout( id [, force_mode ] );
+  // 
+  // Arguments:
+  // 
+  //  id - (String) An optional unique identifier for this doTimeout. If id is
+  //    not specified, the doTimeout will NOT be able to be manually canceled or
+  //    forced.
+  //  delay - (Number) A zero-or-greater delay in milliseconds after which
+  //    callback will be executed. 
+  //  callback - (Function) A function to be executed after delay milliseconds.
+  //  callback - (String) A jQuery method to be executed after delay
+  //    milliseconds. This method will only poll if it explicitly returns
+  //    true.
+  //  force_mode - (Boolean) If true, execute that id's doTimeout callback
+  //    immediately and synchronously, continuing any callback return-true
+  //    polling loop. If false, execute the callback immediately and
+  //    synchronously but do NOT continue a callback return-true polling loop.
+  //    If omitted, cancel that id's doTimeout.
+  // 
+  // Returns:
+  // 
+  //  If force_mode is true, false or undefined and there is a
+  //  yet-to-be-executed callback to cancel, true is returned, but if no
+  //  callback remains to be executed, undefined is returned.
+  
+  $[doTimeout] = function() {
+    return p_doTimeout.apply( window, [ 0 ].concat( aps.call( arguments ) ) );
+  };
+  
+  // Method: jQuery.fn.doTimeout
+  // 
+  // Initialize, cancel, or force execution of a callback after a delay.
+  // Operates like <jQuery.doTimeout>, but the passed callback executes in the
+  // context of the jQuery collection of elements, and the id is stored as data
+  // on the first element in that collection.
+  // 
+  // If delay and callback are specified, a doTimeout is initialized. The
+  // callback will execute, asynchronously, after the delay. If an id is
+  // specified, this doTimeout will override and cancel any existing doTimeout
+  // with the same id. Any additional arguments will be passed into callback
+  // when it is executed.
+  // 
+  // If the callback returns true, the doTimeout loop will execute again, after
+  // the delay, creating a polling loop until the callback returns a non-true
+  // value.
+  // 
+  // Note that if an id is not passed as the first argument, this doTimeout will
+  // NOT be able to be manually canceled or forced (for debouncing, be sure to
+  // specify an id).
+  // 
+  // If id is specified, but delay and callback are not, the doTimeout will be
+  // canceled without executing the callback. If force_mode is specified, the
+  // callback will be executed, synchronously, but will only be allowed to
+  // continue a polling loop if force_mode is true (provided the callback
+  // returns true, of course). If force_mode is false, no polling loop will
+  // continue, even if the callback returns true.
+  // 
+  // Usage:
+  // 
+  // > jQuery('selector').doTimeout( [ id, ] delay, callback [, arg ... ] );
+  // > jQuery('selector').doTimeout( id [, force_mode ] );
+  // 
+  // Arguments:
+  // 
+  //  id - (String) An optional unique identifier for this doTimeout, stored as
+  //    jQuery data on the element. If id is not specified, the doTimeout will
+  //    NOT be able to be manually canceled or forced.
+  //  delay - (Number) A zero-or-greater delay in milliseconds after which
+  //    callback will be executed. 
+  //  callback - (Function) A function to be executed after delay milliseconds.
+  //  callback - (String) A jQuery.fn method to be executed after delay
+  //    milliseconds. This method will only poll if it explicitly returns
+  //    true (most jQuery.fn methods return a jQuery object, and not `true`,
+  //    which allows them to be chained and prevents polling).
+  //  force_mode - (Boolean) If true, execute that id's doTimeout callback
+  //    immediately and synchronously, continuing any callback return-true
+  //    polling loop. If false, execute the callback immediately and
+  //    synchronously but do NOT continue a callback return-true polling loop.
+  //    If omitted, cancel that id's doTimeout.
+  // 
+  // Returns:
+  // 
+  //  When creating a <jQuery.fn.doTimeout>, the initial jQuery collection of
+  //  elements is returned. Otherwise, if force_mode is true, false or undefined
+  //  and there is a yet-to-be-executed callback to cancel, true is returned,
+  //  but if no callback remains to be executed, undefined is returned.
+  
+  $.fn[doTimeout] = function() {
+    var args = aps.call( arguments ),
+      result = p_doTimeout.apply( this, [ doTimeout + args[0] ].concat( args ) );
+    
+    return typeof args[0] === 'number' || typeof args[1] === 'number'
+      ? this
+      : result;
+  };
+  
+  function p_doTimeout( jquery_data_key ) {
+    var that = this,
+      elem,
+      data = {},
+      
+      // Allows the plugin to call a string callback method.
+      method_base = jquery_data_key ? $.fn : $,
+      
+      // Any additional arguments will be passed to the callback.
+      args = arguments,
+      slice_args = 4,
+      
+      id        = args[1],
+      delay     = args[2],
+      callback  = args[3];
+    
+    if ( typeof id !== 'string' ) {
+      slice_args--;
+      
+      id        = jquery_data_key = 0;
+      delay     = args[1];
+      callback  = args[2];
+    }
+    
+    // If id is passed, store a data reference either as .data on the first
+    // element in a jQuery collection, or in the internal cache.
+    if ( jquery_data_key ) { // Note: key is 'doTimeout' + id
+      
+      // Get id-object from the first element's data, otherwise initialize it to {}.
+      elem = that.eq(0);
+      elem.data( jquery_data_key, data = elem.data( jquery_data_key ) || {} );
+      
+    } else if ( id ) {
+      // Get id-object from the cache, otherwise initialize it to {}.
+      data = cache[ id ] || ( cache[ id ] = {} );
+    }
+    
+    // Clear any existing timeout for this id.
+    data.id && clearTimeout( data.id );
+    delete data.id;
+    
+    // Clean up when necessary.
+    function cleanup() {
+      if ( jquery_data_key ) {
+        elem.removeData( jquery_data_key );
+      } else if ( id ) {
+        delete cache[ id ];
+      }
+    };
+    
+    // Yes, there actually is a setTimeout call in here!
+    function actually_setTimeout() {
+      data.id = setTimeout( function(){ data.fn(); }, delay );
+    };
+    
+    if ( callback ) {
+      // A callback (and delay) were specified. Store the callback reference for
+      // possible later use, and then setTimeout.
+      data.fn = function( no_polling_loop ) {
+        
+        // If the callback value is a string, it is assumed to be the name of a
+        // method on $ or $.fn depending on where doTimeout was executed.
+        if ( typeof callback === 'string' ) {
+          callback = method_base[ callback ];
+        }
+        
+        callback.apply( that, aps.call( args, slice_args ) ) === true && !no_polling_loop
+          
+          // Since the callback returned true, and we're not specifically
+          // canceling a polling loop, do it again!
+          ? actually_setTimeout()
+          
+          // Otherwise, clean up and quit.
+          : cleanup();
+      };
+      
+      // Set that timeout!
+      actually_setTimeout();
+      
+    } else if ( data.fn ) {
+      // No callback passed. If force_mode (delay) is true, execute the data.fn
+      // callback immediately, continuing any callback return-true polling loop.
+      // If force_mode is false, execute the data.fn callback immediately but do
+      // NOT continue a callback return-true polling loop. If force_mode is
+      // undefined, simply clean up. Since data.fn was still defined, whatever
+      // was supposed to happen hadn't yet, so return true.
+      delay === undefined ? cleanup() : data.fn( delay === false );
+      return true;
+      
+    } else {
+      // Since no callback was passed, and data.fn isn't defined, it looks like
+      // whatever was supposed to happen already did. Clean up and quit!
+      cleanup();
+    }
+    
+  };
+  
+})(jQuery);

data/vendor/assets/javascripts/dotimeout.js

@@ -0,0 +1 @@
+//= require dotimeout.jquery

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: dotimeout-rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0.0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Martin Harrigan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-22 00:00:00.000000000 Z
+dependencies: []
+description: A gemified version of Ben Alman's jQuery doTimeout plugin.
+email:
+- martinharrigan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- dotimeout-rails.gemspec
+- lib/dotimeout-rails.rb
+- lib/dotimeout-rails/engine.rb
+- lib/dotimeout-rails/version.rb
+- vendor/assets/javascripts/dotimeout.jquery.js
+- vendor/assets/javascripts/dotimeout.js
+homepage: http://github.com/harrigan/dotimeout-rails
+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: '0'
+requirements: []
+rubyforge_project: dotimeout-rails
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A gemified version of Ben Alman's jQuery doTimeout plugin.
+test_files: []