ajaxify_rails 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.idea
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Nico
+
+MIT License
+
+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.md

@@ -0,0 +1,35 @@
+# Nested Form Fields
+
+Rails gem for automatically turning internal links into ajax links that load content without a full page reload.
+
+Uses the html5 history interface for changing the url and making the browser's back and forward buttons working with ajax.
+Falls back to a hash based approach for browsers without the history interface (like Internet Explorer).
+Transparently handles redirects and supports flash messages and page titles. Requires Ruby 1.9 and the asset pipeline.
+
+Inspired by the pjax_rails gem (https://github.com/rails/pjax_rails)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ajaxify_rails'
+
+And then execute:
+
+    $ bundle
+
+In your application.js file add:
+
+    //= require ajaxify_rails
+
+## Usage
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/ajaxify_rails.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/ajaxify_rails/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Nico Ritsche"]
+  gem.email         = ["ncrdevmail@gmail.com"]
+  gem.description   = %q{Rails gem for automatically turning internal links into ajax links that load content without a full page reload.
+                         Uses the html5 history interface for changing the url and making the browser's back and forward buttons working with ajax.
+                         Falls back to a hash based approach for browsers without the history interface (like Internet Explorer).
+                         Transparently handles redirects and supports flash messages and page titles. Requires Ruby 1.9 and the asset pipeline.}
+  gem.summary       = %q{Rails gem for automatically turning internal links into ajax links that load content without a full page reload.}
+  gem.homepage      = "https://github.com/ncri/ajaxify_rails"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "ajaxify_rails"
+  gem.require_paths = ["lib"]
+  gem.version       = AjaxifyRails::VERSION
+
+  gem.add_dependency 'rails', '>= 3.1.0'
+end

data/lib/ajaxify_rails.rb

@@ -0,0 +1,77 @@
+require "ajaxify_rails/version"
+
+module AjaxifyRails
+
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+
+  ActiveSupport.on_load(:action_controller) do
+    include ActionControllerAdditions
+  end
+
+  module ActionControllerAdditions
+
+    def self.included(controller)
+      controller.class_eval do
+
+        private
+
+        def ajaxified?
+          request.xhr? and params[:ajaxified]
+        end
+
+
+        def render *args, &block
+          if ajaxified?
+            args = _normalize_args(*args, &block)
+            layout = args[:layout] || current_layout
+            layout = (layout == 'application' or layout == true) ? false : layout
+            args[:layout] = layout
+            cookies[:flash_notice] = flash[:notice]   # make customizable
+            flash[:notice] = nil
+            extra_content = (respond_to?(:ajaxify_extra_content) ? ajaxify_extra_content : '')
+            super args
+
+            # Store current path for redirect url changes. Also used to remove the ajaxify parameter that gets added to some auto generated urls
+            # like e.g. pagination links see (ajaxify.js -> on_ajaxify_success())
+            #
+            current_url_tag = view_context.content_tag(:span, request.fullpath.sub(/\?ajaxified=true&(.*)/, '?\1').sub(/(&|\?)ajaxified=true/, ''),
+                                                       id: 'ajaxify_location')
+            response_body[0] += view_context.content_tag(:div, current_url_tag + extra_content,
+                                                         id: 'ajaxify_content', style: 'display:none', data: { page_title: try(:page_title) })
+            response.body = self.response_body[0]
+            return
+          end
+          super
+        end
+
+
+        def current_layout
+          return @current_layout if @current_layout
+          @current_layout = _layout
+          @current_layout = File.basename(@current_layout.identifier).split('.').first unless @current_layout.instance_of? String
+          @current_layout
+        end
+
+
+        def redirect_to(options = {}, response_status = {})
+          request.referer.sub!('#/', '') if request.referer  # make redirect to back work for browsers without history api
+
+          super
+
+          ajaxify_params = "ajaxified=true&ajaxify_redirect=true"
+          self.location += "#{self.location =~ /\?/ ? '&' : '?'}#{ajaxify_params}" if request.xhr?  # to avoid the full layout from being rendered
+        end
+
+
+        def ajaxify_redirect_to url
+          render inline: "<%= javascript_tag(\"Ajaxify.load({url: '#{url}'});\") %>", layout: true
+        end
+      end
+
+    end
+  end
+
+end

data/lib/ajaxify_rails/version.rb

@@ -0,0 +1,3 @@
+module AjaxifyRails
+  VERSION = "0.0.1"
+end

data/vendor/assets/javascripts/ajaxify_rails/ajaxify_rails.js.coffee

@@ -0,0 +1,229 @@
+@Ajaxify =
+
+  content_container: 'main'
+  on_before_load: null
+  on_success: null
+  on_success_once: null
+  hash_changed: null
+  ignore_hash_change: null
+  load_page_from_hash: null
+  handle_extra_content: null
+  base_path_regexp: null
+
+  flash_types: ['notice']
+  flash_effect: null
+  clear_flash_effect: null
+
+  initial_history_state:
+    url: window.location.href
+    data:
+      ajaxified: true
+
+
+  init: ->
+
+    if this.load_page_from_hash
+      this.load_page_from_hash = false
+      this.on_hash_change()
+
+    self = this
+
+    protocol_and_hostname = "#{window.location.protocol}//#{window.location.hostname}"
+
+    $('body').on 'click', "a[href^='/']:not(.no_ajaxify), a[href^='#{protocol_and_hostname}']:not(.no_ajaxify)", ->
+
+      $this = $(this)
+      self.load
+        url: $this.attr('href')
+        type: $this.data('method')
+        confirm: $this.data('confirm')
+
+      false
+
+    exclude_selector = ":not(.no_ajaxify):not([enctype='multipart/form-data'])"
+    $('body').on 'submit', "form[action^='/']#{exclude_selector},
+                            form[action^='#{protocol_and_hostname}']#{exclude_selector}", ->
+
+      $this = $(this)
+      form_params = $(this).serialize()
+      form_params += '&ajaxified=true'
+
+      self.load
+        url: $this.attr('action')
+        data: form_params
+        type: $this.attr('method')
+        confirm: $this.data('confirm')
+
+      false
+
+
+    window.onpopstate = (e) ->
+      if e.state
+        e.state.cache = false
+        self.load e.state, true
+
+
+    window.onhashchange = ->
+      self.hash_changed = true
+      if window.location.hash.indexOf('#/') == 0  # only react to hash changes if hash starts with '/'
+        unless self.ignore_hash_change
+          self.on_hash_change()
+        else
+          self.ignore_hash_change = false
+
+
+  on_hash_change: ->
+    url = window.location.hash.replace(/#/, "")
+    if url == ''
+      url = '/'
+    this.load
+      url: url
+    self.hash_changed = false
+
+
+  load: (options, pop_state = false) ->
+
+    unless this.load_page_from_hash
+      self = this
+
+      data = options.data || { ajaxified: true }
+
+      if options.type and options.type == 'delete'
+        type = 'post'
+        if self.is_string(data)
+          data += '&_method=delete'
+        else
+          data._method = 'delete'
+      else
+        type = options.type or 'get'
+
+      if options.confirm
+        return false unless confirm options.confirm
+
+      if self.on_before_load
+        self.on_before_load options.url
+
+      $.ajax
+        url: options.url
+        dataType: 'html'
+        data:  data
+        type: type
+        cache: true
+        beforeSend: (xhr) ->
+          $("##{self.content_container}").html( "<div class='ajaxify_loader'></div>" )
+          $('html, body').animate
+            scrollTop:0
+            , 500
+
+        success: (data, status, jqXHR) ->
+          self.on_ajaxify_success data, status, jqXHR, pop_state, options
+
+
+  show_flash: () ->
+    self = this
+    $.each this.flash_types, ->
+      cookie_name = "flash_#{this}"
+      if $.cookie cookie_name
+        $("##{this}").html $.cookie(cookie_name)
+        $.cookie cookie_name, null
+        $("##{this}").show()
+        if self.flash_effect
+          self.flash_effect this
+      else
+        if self.clear_flash_effect
+          self.clear_flash_effect this
+        $("##{this}").hide()
+
+
+  on_ajaxify_success: (data, status, jqXHR, pop_state, options) ->
+
+    $("##{this.content_container}").html data
+
+    title = $('#ajaxify_content').data('page-title')
+
+    # Correct the url after a redirect and when it has the ajaxify param in it.
+    # The latter can happen e.g. for pagination links that are auto generated.
+    current_url = $('#ajaxify_content #ajaxify_location').text()
+    if options.url != current_url
+      options.url = current_url.replace(/(&|\?)ajaxify_redirect=true/,'')
+      options.type = 'GET'
+
+    this.update_url options, pop_state
+
+    if this.handle_extra_content
+      this.handle_extra_content()
+
+    $("##{this.content_container} #ajaxify_content").remove()
+
+    if title != ''
+      document.title = title.replace /&amp;/, '&'   # Todo: need to figure out what else needs to be unescaped
+
+    this.show_flash()
+
+    if this.on_success
+      this.on_success( data, status, jqXHR, options.url )
+
+    if this.on_success_once
+      this.on_success_once( data, status, jqXHR )
+      this.on_success_once = null
+
+
+  update_url: (options, pop_state = false) ->
+
+    get_request = (!options.type or options.type.toLowerCase() == 'get')
+
+    # unless back/forward arrowing or request method is not 'get'
+    if !pop_state and get_request
+
+      if window.history.pushState
+
+        if this.initial_history_state != ''
+          window.history.replaceState this.initial_history_state, ''
+          this.initial_history_state = ''
+
+        window.history.pushState
+          url: options.url
+          data: options.data
+          type: options.type
+        ,'', options.url
+
+      else
+        this.ignore_hash_change = true  # avoids loading the page for hash changes caused by link clicks
+        hash = "#{options.url.replace(new RegExp(this.protocol_with_host()), '')}"
+        if this.base_path_regexp
+          hash = hash.replace(this.base_path_regexp, '')
+        window.location.hash = hash
+
+
+
+  protocol_with_host: ->
+    loc = window.location
+    "#{loc.protocol}//#{loc.host}"
+
+
+  correct_url: ->
+    if window.location.hash.indexOf('#/') == 0
+      if !window.history.pushState
+        Ajaxify.load_page_from_hash = true   # notify Ajaxify that a hash will be loaded and ignore all other calls to load until hash url is loaded
+      else
+        path = window.location.pathname + window.location.hash.replace(/#\//, "")       # load proper url in case url contains #/ and browser supports history api
+        window.location.href = "#{this.protocol_with_host()}#{path}"
+
+    else if !window.history.pushState and window.location.pathname != '/'
+      if this.base_path_regexp and (match = window.location.pathname.match(this.base_path_regexp))
+        path = "#{match[0]}/##{window.location.pathname}"
+        if match[0] == window.location.pathname then return
+      else
+        path = "/##{window.location.pathname}"
+
+      window.location.href = "#{this.protocol_with_host()}#{path}#{window.location.search}"  # move path behind # for browsers without history api if not at site root
+
+
+  is_string: (variable) ->
+    Object.prototype.toString.call(variable) == '[object String]'
+
+
+Ajaxify.correct_url()
+
+jQuery ->
+  Ajaxify.init()

data/vendor/assets/javascripts/ajaxify_rails/index.js

@@ -0,0 +1,2 @@
+//= require ./jquery_cookie
+//= require ./ajaxify_rails

data/vendor/assets/javascripts/ajaxify_rails/jquery_cookie.js

@@ -0,0 +1,61 @@
+/*jshint eqnull:true */
+/*!
+ * jQuery Cookie Plugin v1.1
+ * https://github.com/carhartl/jquery-cookie
+ *
+ * Copyright 2011, Klaus Hartl
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.opensource.org/licenses/GPL-2.0
+ */
+(function($, document) {
+
+	var pluses = /\+/g;
+	function raw(s) {
+		return s;
+	}
+	function decoded(s) {
+		return decodeURIComponent(s.replace(pluses, ' '));
+	}
+
+	$.cookie = function(key, value, options) {
+
+		// key and at least value given, set cookie...
+		if (arguments.length > 1 && (!/Object/.test(Object.prototype.toString.call(value)) || value == null)) {
+			options = $.extend({}, $.cookie.defaults, options);
+
+			if (value == null) {
+				options.expires = -1;
+			}
+
+			if (typeof options.expires === 'number') {
+				var days = options.expires, t = options.expires = new Date();
+				t.setDate(t.getDate() + days);
+			}
+
+			value = String(value);
+
+			return (document.cookie = [
+				encodeURIComponent(key), '=', options.raw ? value : encodeURIComponent(value),
+				options.expires ? '; expires=' + options.expires.toUTCString() : '', // use expires attribute, max-age is not supported by IE
+				options.path    ? '; path=' + options.path : '',
+				options.domain  ? '; domain=' + options.domain : '',
+				options.secure  ? '; secure' : ''
+			].join(''));
+		}
+
+		// key and possibly options given, get cookie...
+		options = value || $.cookie.defaults || {};
+		var decode = options.raw ? raw : decoded;
+		var cookies = document.cookie.split('; ');
+		for (var i = 0, parts; (parts = cookies[i] && cookies[i].split('=')); i++) {
+			if (decode(parts.shift()) === key) {
+				return decode(parts.join('='));
+			}
+		}
+		return null;
+	};
+
+	$.cookie.defaults = {};
+
+})(jQuery, document);

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: ajaxify_rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nico Ritsche
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: ! "Rails gem for automatically turning internal links into ajax links
+  that load content without a full page reload.\n                         Uses the
+  html5 history interface for changing the url and making the browser's back and forward
+  buttons working with ajax.\n                         Falls back to a hash based
+  approach for browsers without the history interface (like Internet Explorer).\n
+  \                        Transparently handles redirects and supports flash messages
+  and page titles. Requires Ruby 1.9 and the asset pipeline."
+email:
+- ncrdevmail@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ajaxify_rails.gemspec
+- lib/ajaxify_rails.rb
+- lib/ajaxify_rails/version.rb
+- vendor/assets/javascripts/ajaxify_rails/ajaxify_rails.js.coffee
+- vendor/assets/javascripts/ajaxify_rails/index.js
+- vendor/assets/javascripts/ajaxify_rails/jquery_cookie.js
+homepage: https://github.com/ncri/ajaxify_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'
+      segments:
+      - 0
+      hash: -44075291166774192
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -44075291166774192
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Rails gem for automatically turning internal links into ajax links that load
+  content without a full page reload.
+test_files: []