remoteable 1.0.0

data/.gitignore

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

data/Gemfile

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

data/README.md

@@ -0,0 +1,67 @@
+# Remoteable
+
+Remoteable is meant to be a simple set of conventions about how data is loaded into
+a browser. The main idea goes back to the idea of how a browser loads built-in elements that aren't 
+inline text. Specifically, the whole idea of remoteable came from the realization that we've been using the
+"Asynchronous" from "AJAX" since the first day we wrote an `<img>` tag. For example:
+
+	<img src="http://upload.wikimedia.org/wikipedia/commons/6/63/Wikipedia-logo.png">
+	
+What does the browser do when it sees this in the HTML? It goes off, starts downloading the picture and
+then renders the picture and inserts it where the `<img>` tag lives in the rendered document. What
+we've been doing by manually managing AJAX requests that go out, get some content, and inject it into the
+resulting document is akin to manually downloading the images and injecting the result into the DOM. This
+took me a bit to really grasp. Here's the core remoteable idea:
+
+	<div id="mydiv" data-src="http://somewhere.com/users/3">
+	
+In this instance treat the rendered user div on the page as a single resource that you go out and download and
+then inject into the DOM as a replacement for the `<div>` placeholder. 
+	
+Triggering it to load itself can be done a number of ways. You can target the div yourself:
+
+	$("#mydiv").trigger("refresh")
+	
+You can do a search for divs that have a common URL
+
+	$("*:remoteable(http://somewhere.com/users/3)").trigger("refresh")
+	
+You can refresh all the remoteables:
+	
+	$.remoteables.trigger("refresh")
+	
+And so on. 
+		
+## Delegates
+
+There are many times where one part of the page needs to be updated with some content. Given that a remoteable
+div has a data-src it's very easy to tell the div to refresh itself, but a common pattern is changing the 
+div's `data-src` attribute and asking it to refresh. Handling this pattern is as simple as:
+
+	<div data-remote-delegate="#some_selector" data-src="http://somewhere.com/users/3">
+	
+When a click event hits this element (either directly or through event bubbling), remoteable will wrap the `data-remote-delegate`
+value in a jQuery selector and call `remoteable("update")` with its own `data-src` url and asks it to refresh. This is roughly
+equivalent to:
+	
+	$("#some_selector").remoteable("update", {url: "http://somewhere.com/users/3"}).trigger("refresh.remoteable");
+	
+This way, the target element(s) become remoteable (if they weren't already), and the rest of the remoteable flow happens
+as normal. Note, the original event continues to bubble but preventDefault is called on it. 
+
+If the target element is already loading a request that request will be cancelled first. 
+
+## Content on the way back
+
+When the remoteable request completes the target element will check the response type. If it's HTML it will replace its content
+with what was returned by the AJAX request. If you'd rather that the returned content *replace* the remoteable, just add
+`data-replace-self=true` to the element:
+
+	<div data-src="http://somewhere.com/users/3" data-replace-self="true">
+	
+This is useful for divs that show loading status and should be removed once loading is complete. This way you don't have to worry
+about cleaning up the loading div as it is handled automatically.
+
+## Redirects
+
+TODO: writeup

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/helpers/remoteable_helper.rb

@@ -0,0 +1,61 @@
+module RemoteableHelper
+  def remote_content_tag(tag, options = {}, &block)
+    normalize_remoteable_params!(options)
+
+    content_tag(tag, options) do
+      yield if options['data-loaded']
+    end
+  end
+
+  def link_to_refresh(link, target, options = {})
+    normalize_remoteable_params!(options)
+
+    link_to link, target, options
+  end
+
+  def link_to_remoteable(link, options = {})
+    normalize_remoteable_params!(options)
+
+    link_to_function link, "", options
+  end
+
+  def refresh_remoteable(options)
+    normalize_remoteable_params!(options)
+
+    %Q{$.remoteables("#{j options["data-src"]}").remoteable("refresh")}
+  end
+
+  private
+
+  def polymorphic_link_from_options(url, options = {})
+    return url if url.is_a?(String)
+    args = [url]
+    args << {:format => options[:format]} if options[:format]
+    polymorphic_url(*args)
+  end
+
+  def normalize_remoteable_params!(options)
+    data_method = options[:method] || "get"
+    
+    if(options[:url])
+      url = polymorphic_link_from_options(options[:url], options)
+      options['data-src'] = url
+      options['data-method'] = data_method
+    end
+
+    options['data-loaded'] = !!options[:loaded]
+    Rails.logger.info("Data loaded: #{options['data-loaded']}")
+    options[:class] = options[:loaded_class] if options[:loaded] && options[:loaded_class]
+
+    options[:style] = "display: none;" if options[:hide_until_loaded] && !options['data-loaded']
+
+    options.delete(:method)
+    options.delete(:url)
+    options.delete(:format)
+    options.delete(:loaded)
+    options.delete(:hide_until_loaded)
+    options.delete(:loaded_class)    
+  end
+
+
+end

data/lib/assets/javascripts/remoteable.js

@@ -0,0 +1,185 @@
+(function($) {
+
+    $.extend(
+        $.expr[":"], {
+            remoteable: function(elem, i, match, array) {
+                var url = match[3].split(",")[0];
+                var method = match[3].split(",")[1] || "get";
+                return $(elem).data("src") == url && $(elem).data("method") == method;
+            }
+        }
+    );
+
+    $.remoteables = function(url, method) {
+        var remoteables = "*[data-src]";
+        if(url) {
+            remoteables += "[data-src^='" + url + "']";
+        }
+        if(method) {
+            remoteables += "[data-method='" + method + "']";
+        }
+
+        return $(remoteables);
+    }
+
+    var httpMethods = {
+        put: function(options) {
+            if(options.data == undefined) {
+                options.data = {};
+            }
+            options.data._method = 'PUT';
+            options.type = "POST";
+            return $.ajax(options);
+        },
+        delete: function(options) {
+            if(options.data == undefined) {
+                options.data = {};
+            }
+            options.data._method = 'DELETE';
+            options.type = "POST";
+            return $.ajax(options);
+        },
+        post: function(options) {
+            options.type = "POST";
+            return $.ajax(options);
+        },
+        get: function(options) {
+            options.type = "GET";
+            return $.ajax(options);
+        }
+    };
+
+    var methods = {
+        init: function(options) {
+            options = options || {};
+            return this.each(function() {
+                var $this = $(this),
+                    data = $this.data('remoteable');
+                // If the plugin hasn't been initialized yet
+                if(!data) {
+                    /*
+                     Do more setup stuff here
+                     */
+                    $(this).data('remoteable', {
+                        target: $this
+                    });
+
+                    var self = $(this);
+                    var method = options["method"] || self.data("method") || "get";
+                    self.attr("data-method", method);
+                    var url = options["url"] || self.data("src");
+                    self.attr("data-src", url);
+
+                    self.on("click.remoteable", function(event) {
+                        if(self.data("remote-delegate")) {
+                            $(self.data('remote-delegate')).remoteable("update", {url: url});
+                        } else {
+                            if(self.is("a")) {
+                                event.preventDefault();
+                                if(self.data("remoteable").currentRequest) {
+                                    self.data("remoteable").currentRequest.abort();
+                                }
+                                self.data("remoteable").currentRequest = httpMethods[method].call(self, {
+                                    url: url,
+                                    complete: function(jqXHR, textStatus) {
+                                        self.data("remoteable").currentRequest = null;
+                                    }
+                                });
+                                event.stopPropagation();
+                            }
+                        }
+                    });
+
+                    self.on("refresh.remoteable", function(event) {
+                        var url = self.data("src");
+                        event.preventDefault();
+                        event.stopPropagation();
+
+                        if(self.is(":not(a)")) {
+							self.addClass("remoteable-processing");
+                            if(self.data("remoteable").currentRequest) {
+                                self.data("remoteable").currentRequest.abort();
+                            }
+                            self.data("remoteable").currentRequest = httpMethods[method].call(self, {
+                                url: url,
+                                complete: function(jqXHR, textStatus) {
+									self.removeClass("remoteable-processing");
+                                    self.trigger("ajax:complete.remoteable", [jqXHR, textStatus]);
+                                }
+                            });
+                        }
+                    });
+
+                    self.on("ajax:complete.remoteable", function(event, jqXHR, textStatus) {
+                        event.stopPropagation();
+                        event.preventDefault();
+                        self.data("remoteable").currentRequest = null;
+                        var ct = jqXHR.getResponseHeader("content-type") || "";
+                        if(ct.indexOf('html') > -1) {
+                            var returned = $(jqXHR.responseText);
+							if(self.data("replace-self")) {
+								self.replaceWith(returned);
+							} else {
+                            	self.html(returned);								
+                            	self.trigger("refreshed.remoteable", [self.data("src")]);
+							}
+                        }
+                        if(ct.indexOf('json') > -1) {
+                            var url = $.parseJSON(jqXHR.responseText).redirect_to;
+                            self.remoteable("update", {url: url});
+                        }
+                    });
+
+                }
+            });
+        },
+
+        destroy: function() {
+            return this.each(function() {
+                var $this = $(this),
+                    data = $this.data('remoteable');
+
+                $this.removeData('remoteable');
+            });
+        },
+
+        refreshAll: function(options) {
+            $.remoteables().remoteable("refresh");
+        },
+
+        initAll: function(options) {
+            $.remoteables().remoteable();
+        },
+
+        update: function(options) {
+            return this.each(function() {
+                var self = $(this);
+                self.remoteable();
+                if(options.url) {
+                    self.data("src", options.url);
+                }
+                self.trigger("refresh.remoteable");
+            });
+        },
+
+        refresh: function(options) {
+            return this.each(function() {
+                var self = $(this);
+                self.trigger("refresh.remoteable");
+            });
+        }
+    };
+
+    $.fn.remoteable = function(method) {
+
+        if(methods[method]) {
+            return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
+        } else if(typeof method === 'object' || !method) {
+            return methods.init.apply(this, arguments);
+        } else {
+            $.error('Method ' + method + ' does not exist on jQuery.remoteable');
+        }
+
+    };
+
+})(jQuery);

data/lib/remoteable.rb

@@ -0,0 +1,7 @@
+require "remoteable/version"
+
+module Remoteable
+  # Your code goes here...
+end
+
+require 'remoteable/engine' if defined?(Rails)

data/lib/remoteable/engine.rb

@@ -0,0 +1,7 @@
+module Remoteable
+  class Engine < Rails::Engine
+    config.to_prepare do
+      ActionController::Base.send(:helper, RemoteableHelper)
+    end
+  end
+end

data/lib/remoteable/version.rb

@@ -0,0 +1,3 @@
+module Remoteable
+  VERSION = "1.0.0"
+end

data/remoteable.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "remoteable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "remoteable"
+  s.version     = Remoteable::VERSION
+  s.authors     = ["Andrew Eberbach"]
+  s.email       = ["andrew@ebertech.ca"]
+  s.homepage    = ""
+  s.summary     = %q{Remoteable AJAX content helper}
+
+  s.rubyforge_project = "remoteable"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: remoteable
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Andrew Eberbach
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-31 00:00:00 Z
+dependencies: []
+
+description: 
+email: 
+- andrew@ebertech.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- app/helpers/remoteable_helper.rb
+- lib/assets/javascripts/remoteable.js
+- lib/remoteable.rb
+- lib/remoteable/engine.rb
+- lib/remoteable/version.rb
+- remoteable.gemspec
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: remoteable
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Remoteable AJAX content helper
+test_files: []
+
+has_rdoc: