ajax 0.1.2

data/lib/ajax/action_controller.rb

@@ -0,0 +1,154 @@
+module Ajax
+  module ActionController
+    def self.included(klass)      
+      klass.class_eval do
+        alias_method_chain :render, :ajax
+        alias_method_chain :redirect_to_full_url, :ajax
+
+        append_after_filter :process_response_headers
+      end
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # Set a custom response header if the request is AJAX.
+      #
+      # Call with <tt>key</tt> and optional <tt>value</tt>.  Pass a
+      # block to yield a dynamic value.
+      #
+      # Accepts :only and :except conditions because we create
+      # an after_filter.
+      def ajax_header(*args, &block)
+        return unless Ajax.is_enabled?
+
+        options = args.extract_options!
+        key, value = args.shift, args.shift
+        value = block_given? ? Proc.new : value
+
+        prepend_after_filter(options) do |controller|
+          if controller.request.xhr?
+            value = value.is_a?(Proc) ? controller.instance_eval(&value) : value
+            Ajax.set_header(controller.response, key, value)
+          end
+        end
+      end
+
+      # Set the layout to use for AJAX requests.
+      #
+      # By default we look in layouts/ajax/ for this controllers default
+      # layout and render that.  If it can't be found, the default layout
+      # is used.
+      def ajax_layout(template_name)
+        write_inheritable_attribute(:ajax_layout, template_name)
+      end
+    end
+
+    protected
+
+      # Redirect to hashed URLs unless the path is excepted.
+      #
+      # Store the URL that we are redirecting to in the session.
+      # If we then have a request for the root URL we know
+      # to render this URL into it.
+      #
+      # If redirecting back to the referer, use the referer
+      # in the Ajax-Info header because it includes the
+      # hashed part of the URL.  Otherwise the referer is
+      # always the root url.
+      #
+      # For AJAX requests, respond with an AJAX-suitable
+      # redirect.
+      def redirect_to_full_url_with_ajax(url, status)
+        return redirect_to_full_url_without_ajax(url, status) unless Ajax.is_enabled?
+        raise DoubleRenderError if performed?
+        
+        if url == request.headers["Referer"] && !request.headers['Ajax-Info'].blank?
+          url = request.headers['Ajax-Info']['referer']
+          Ajax.logger.debug("[ajax] using referer #{url} from Ajax-Info")
+        end
+
+        if !Ajax.exclude_path?(url) && !Ajax.is_hashed_url?(url)
+          url = Ajax.hashed_url_from_traditional(url)
+          Ajax.logger.info("[ajax] rewrote redirect to #{url}")
+        end
+
+        session[:redirected_to] = url
+        if request.xhr?
+          render(:update) { |page| page.redirect_to(url) }
+        else
+          redirect_to_full_url_without_ajax(url, status)
+        end
+      end
+
+      # Convert the Ajax-Info hash to JSON before the request is sent.
+      def process_response_headers
+        case response.headers['Ajax-Info']
+        when Hash
+          response.headers['Ajax-Info'] = response.headers['Ajax-Info'].to_json
+        end
+      end
+
+      #
+      # Intercept rendering to customize the headers and layout handling
+      #
+      def render_with_ajax(options = nil, extra_options = {}, &block)
+        return render_without_ajax(options, extra_options, &block) unless Ajax.is_enabled?
+        
+        original_args = [options, extra_options]
+        if request.xhr?
+
+          # Options processing taken from ActionController::Base#render
+          if options.nil?
+            options = { :template => default_template, :layout => true }
+          elsif options == :update
+            options = extra_options.merge({ :update => true })
+          elsif options.is_a?(String) || options.is_a?(Symbol)
+            case options.to_s.index('/')
+            when 0
+              extra_options[:file] = options
+            when nil
+              extra_options[:action] = options
+            else
+              extra_options[:template] = options
+            end
+            options = extra_options
+          elsif !options.is_a?(Hash)
+            extra_options[:partial] = options
+            options = extra_options
+          end
+
+          default = pick_layout(options)
+          default = default.path_without_format_and_extension unless default.nil?
+          ajax_layout = layout_for_ajax(default)
+          ajax_layout = ajax_layout.path_without_format_and_extension unless ajax_layout.nil?
+          options[:layout] = ajax_layout unless ajax_layout.nil?
+
+          # Send the current layout and controller in a custom response header
+          Ajax.set_header(response, :layout, ajax_layout)
+          Ajax.set_header(response, :controller, self.class.controller_name)
+        end
+        render_without_ajax(options, extra_options, &block)
+      end
+
+      # Return the layout to use for an AJAX request, or the default layout if one
+      # cannot be found.  If no default is known, <tt>layouts/ajax/application</tt> is used.
+      #
+      # If no ajax_layout is set, look for the default layout in <tt>layouts/ajax</tt>.
+      # If the layout cannot be found, use the default.
+      #
+      # FIXME: Use hard-coded html layout extension because <tt>default_template_format</tt>
+      # is sometimes :js which means the layout isn't found.
+      def layout_for_ajax(default) #:nodoc:
+        ajax_layout = self.class.read_inheritable_attribute(:ajax_layout)
+        if ajax_layout.nil? || !(ajax_layout =~ /^layouts\/ajax/)
+          find_layout("layouts/ajax/#{default.sub(/layouts(\/)?/, '')}", 'html') unless default.nil?
+        else
+          ajax_layout
+        end
+      rescue ::ActionView::MissingTemplate
+        Ajax.logger.info("[ajax] no layout found in layouts/ajax using #{default}")
+        default
+      end
+  end
+end

data/lib/ajax/action_view.rb

@@ -0,0 +1,56 @@
+module Ajax
+  module ActionView
+    def self.included(klass)
+      klass.class_eval do
+        alias_method_chain :link_to, :ajax if method_defined?(:link_to)
+      end
+      klass.send(:include, Helpers)
+    end
+
+    module Helpers
+
+      # Set a custom response header if the request is AJAX.
+      def ajax_header(key, value)
+        return unless Ajax.is_enabled? && request.xhr?
+        Ajax.set_header(response, key, value)
+      end
+    end
+
+    protected
+
+      # Include an attribute on all outgoing links to mark them as Ajax deep links.
+      #
+      # The deep link will be the path and query string from the href.
+      #
+      # To specify a different deep link pass <tt>:data-deep-link => '/deep/link/path'</tt>
+      # in the <tt>link_to</tt> <tt>html_options</tt>.
+      #
+      # To turn off deep linking for a URL, pass <tt>:traditional => true</tt> or
+      # <tt>:data-deep-link => nil</tt>.
+      #
+      # Any paths matching the paths in Ajax.exclude_paths will automatically be
+      # linked to traditionally.
+      def link_to_with_ajax(*args, &block)
+        if Ajax.is_enabled? && !block_given?
+          options      = args.second || {}
+          html_options = args.third
+          html_options = (html_options || {}).stringify_keys
+
+          # Insert the deep link unless the URL is traditional
+          if !html_options.has_key?('data-deep-link') && !html_options.delete('traditional')
+            path = url_for(options)
+
+            # Is this path to be excluded?
+            unless Ajax.exclude_path?(path)
+              if path.match(%r[^(http:\/\/[^\/]*)(\/?.*)])
+                path = $2
+              end
+              html_options['data-deep-link'] = path
+            end
+          end
+          args[2] = html_options
+        end
+        link_to_without_ajax(*args, &block)
+      end
+  end
+end

data/lib/ajax/helpers.rb

@@ -0,0 +1,15 @@
+require 'ajax/helpers/request_helper'
+require 'ajax/helpers/robot_helper'
+require 'ajax/helpers/url_helper'
+
+module Ajax #:nodoc:
+  module Helpers #:nodoc:
+    def self.included(klass)
+      klass.class_eval do
+        extend RequestHelper
+        extend RobotHelper
+        extend UrlHelper   
+      end     
+    end
+  end
+end

data/lib/ajax/helpers/request_helper.rb

@@ -0,0 +1,76 @@
+module Ajax
+  module Helpers
+    module RequestHelper
+      # Recursive merge values
+      DEEP_MERGE = lambda do |key, v1, v2|
+        if v1.is_a?(Hash) && v2.is_a?(Hash)
+          v1.merge(v2, &DEEP_MERGE)
+        elsif v1.is_a?(Array) && v2.is_a?(Array)
+          v1.concat(v2)
+        else
+          [v1, v2].compact.first
+        end
+      end
+
+      # Hash and/or Array values are merged so you can set multiple values
+      def set_header(object, key, value)
+        headers = object.is_a?(::ActionController::Response) ? object.headers : object
+        unless headers["Ajax-Info"].is_a?(Hash)
+          headers["Ajax-Info"] = {}
+        end
+
+        # Deep merge hashes
+        if headers["Ajax-Info"].has_key?(key.to_s) &&
+            value.is_a?(Hash) &&
+            headers["Ajax-Info"][key.to_s].is_a?(Hash)
+          value = headers["Ajax-Info"][key.to_s].merge(value, &DEEP_MERGE)
+        end
+
+        # Concat arrays
+        if headers["Ajax-Info"].has_key?(key.to_s) &&
+            value.is_a?(Array) &&
+            headers["Ajax-Info"][key.to_s].is_a?(Array)
+          value = headers["Ajax-Info"][key.to_s].concat(value)
+        end
+      
+        headers["Ajax-Info"][key.to_s] = value
+      end
+
+      def get_header(object, key)
+        headers = object.is_a?(::ActionController::Request) ? object.headers : object
+        unless headers["Ajax-Info"].is_a?(Hash)
+          headers["Ajax-Info"] = {}
+        end
+        headers['Ajax-Info'][key.to_s]
+      end
+
+      # Set one or more paths that can be accessed directly without the AJAX framework.
+      #
+      # Useful for excluding pages with HTTPS content on them from being loaded
+      # via AJAX.
+      #
+      # <tt>paths</tt> a list of String or Regexp instances that are matched
+      # against each REQUEST_PATH.
+      #
+      # The string and regex paths are modified to match full URLs by prepending
+      # them with the appropriate regular expression.
+      def exclude_paths(paths=nil)
+        if !instance_variable_defined?(:@exclude_paths)
+          @exclude_paths = []
+        end
+        (paths || []).each do |path|
+          @exclude_paths << /^(\w+\:\/\/[^\/]+\/?)?#{path.to_s}$/
+        end
+        @exclude_paths
+      end
+
+      # Return a boolean indicating whether or not to exclude a path from the
+      # AJAX redirect.
+      def exclude_path?(path)
+        !!((@exclude_paths || []).find do |excluded|
+          !!excluded.match(path)
+        end)
+      end
+    end
+  end
+end

data/lib/ajax/helpers/robot_helper.rb

@@ -0,0 +1,31 @@
+module Ajax
+  module Helpers
+    module RobotHelper
+      ROBOTS = [
+        {:name => 'Googlebot', :user_agent_regex => /\bGooglebot\b/i, :sample_agent_string => 'Googlebot'},
+        {:name => 'Baidu', :user_agent_regex => /\bBaidu\b/i, :sample_agent_string => 'Baidu'},
+        {:name => 'Gigabot', :user_agent_regex => /\bGigabot\b/i, :sample_agent_string => 'Gigabot'},
+        {:name => 'libwww-perl', :user_agent_regex => /\blibwww-perl\b/i, :sample_agent_string => 'libwww-perl'},
+        {:name => 'lwp-trivial', :user_agent_regex => /\blwp-trivial\b/i, :sample_agent_string => 'lwp-trivial'},
+        {:name => 'MSNBot', :user_agent_regex => /\bmsnbot\b/i, :sample_agent_string => 'msnbot'},
+        {:name => 'SiteUptime', :user_agent_regex => /\bSiteUptime\b/i, :sample_agent_string => 'SiteUptime'},
+        {:name => 'Slurp', :user_agent_regex => /\bSlurp\b/i, :sample_agent_string => 'Slurp'},
+        {:name => 'WordPress', :user_agent_regex => /\bWordPress\b/i, :sample_agent_string => 'WordPress'},
+        {:name => 'ZIBB', :user_agent_regex => /\bZIBB\b/i, :sample_agent_string => 'ZIBB'},
+        {:name => 'ZyBorg', :user_agent_regex => /\bZyBorg\b/i, :sample_agent_string => 'ZyBorg'},
+      ]
+
+      def robot_for(user_agent)
+        ROBOTS.each do |r|
+          return r if user_agent =~ r[:user_agent_regex]
+        end
+        nil
+      end
+    
+      # Call with a User Agent string
+      def is_robot?(user_agent)
+        !!self.robot_for(user_agent)
+      end    
+    end
+  end
+end

data/lib/ajax/helpers/url_helper.rb

@@ -0,0 +1,47 @@
+module Ajax
+  module Helpers
+    module UrlHelper
+
+      # Return a boolean indicating whether the given URL points to the
+      # root path.
+      def url_is_root?(url)
+        !!(URI.parse(url).path =~ %r[^\/?$])
+      end
+
+      # The URL is hashed if the fragment part starts with a /
+      #
+      # For example, http://lol.com#/Rihanna
+      def is_hashed_url?(url)
+        !!(URI.parse(url).fragment =~ %r[^\/])
+      end
+
+      # Return a hashed URL using the fragment of <tt>url</tt>
+      def hashed_url_from_fragment(url)
+        url_host(url) + ('/#/' + (URI.parse(url).fragment || '')).gsub(/\/\//, '/')
+      end
+
+      # Return a traditional URL from the fragment of <tt>url</tt>
+      def traditional_url_from_fragment(url)
+        url_host(url) + ('/' + (URI.parse(url).fragment || '')).gsub(/\/\//, '/')
+      end
+
+      # Return a hashed URL formed from a traditional <tt>url</tt>
+      def hashed_url_from_traditional(url)
+        uri = URI.parse(url)
+        hashed_url = url_host(url) + ('/#/' + (uri.path || '')).gsub(/\/\//, '/')
+        hashed_url += ('?' + uri.query) unless uri.query.nil?
+        hashed_url
+      end
+
+      protected
+
+      def url_host(url)
+        if url.match(/^(\w+\:\/\/[^\/]+)\/?/)
+          $1
+        else
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/ajax/railtie.rb

@@ -0,0 +1,7 @@
+module SitemapGenerator
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load(File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'tasks', 'ajax_tasks.rake')))
+    end
+  end
+end

data/lib/ajax/routes.rb

@@ -0,0 +1,12 @@
+module Ajax
+  module Routes
+    # In your <tt>config/routes.rb</tt> file call:
+    #   Ajax::Routes.draw(map)
+    # Passing in the routing <tt>map</tt> object.
+    #
+    # Adds an <tt>ajax_framework_path</tt> pointing to <tt>/ajax/framework</tt>
+    def self.draw(map)
+      map.ajax_framework "/ajax/framework", :controller => 'ajax', :action => 'framework'
+    end
+  end
+end

data/lib/ajax/spec/extension.rb

@@ -0,0 +1,34 @@
+module Ajax
+  module Spec
+    module Extension
+
+      def integrate_ajax
+        Ajax.enabled = true
+      end
+
+      def disable_ajax
+        Ajax.enabled = false
+      end
+      
+      def mock_ajax
+        integrate_ajax
+        Ajax.mocked = true
+      end
+      
+      def unmock_ajax
+        disable_ajax
+        Ajax.mocked = false
+      end      
+    end
+  end
+end
+
+module ActiveSupport
+  class TestCase
+    include Ajax::Spec::Extension
+
+    before(:all) do
+      ::Ajax.enabled = false
+    end if method_defined?(:before)
+  end
+end

data/lib/ajax/spec/helpers.rb

@@ -0,0 +1,95 @@
+require 'uri'
+
+module Ajax
+  module Spec
+    module Helpers
+
+      def create_app
+        @app = Class.new { def call(env); true; end }.new
+      end
+
+      def call_rack(url, request_method='GET', env={}, &block)
+        env(url, request_method, env)
+        @rack = Rack::Ajax.new(@app, &block)
+        @response = @rack.call(@env)
+      end
+
+      def should_respond_with(msg)
+        should_be_a_valid_response
+        response_body.should == msg
+      end
+
+      def should_redirect_to(location, code=302)
+        should_be_a_valid_response
+        response_code.should == code
+        response_headers['Location'].should == location
+      end
+
+      def should_set_ajax_response_header(key, value)
+        response_headers['Ajax-Info'][key].should == value
+      end
+
+      def should_set_ajax_request_header(key, value)
+        @env['Ajax-Info'][key].should == value
+      end
+            
+      def should_rewrite_to(url)
+        should_be_a_valid_response
+
+        # Check custom headers
+        response_body_as_hash['REQUEST_URI'].should == url
+      end
+
+      def should_not_modify_request
+        should_be_a_valid_response
+        response_code.should == 200
+
+        # If we have the original headers from a call to call_rack()
+        # check that they haven't changed.  Otherwise, just make sure
+        # that we don't have the custom rewrite header.
+        if !@env.nil?
+          @env.each { |k,v| response_body_as_hash.should == v }
+        end
+      end
+
+      # Response must be [code, {headers}, ['Response']]
+      # Headers must contain the Content-Type header
+      def should_be_a_valid_response
+        return if @response.is_a?(::ActionController::Response)
+        @response.should be_a_kind_of(Array)
+        @response.size.should == 3
+        @response[0].should be_a_kind_of(Integer)
+        @response[1].should be_a_kind_of(Hash)
+        @response[1]['Content-Type'].should =~ %r[^text\/\w+]
+        @response[2].should be_a_kind_of(Array)
+        @response[2][0].should be_a_kind_of(String)
+      end
+
+      def env(uri, request_method, options={})
+        uri = URI.parse(uri)
+        @env = {
+          'REQUEST_URI' => uri.to_s,
+          'PATH_INFO' => uri.path,
+          'QUERY_STRING' => uri.query,
+          'REQUEST_METHOD' => request_method
+        }.merge!(options)
+      end
+
+      def response_body
+        @response.is_a?(::ActionController::Response) ? @response.body : @response[2][0]
+      end
+
+      def response_code
+        @response.is_a?(::ActionController::Response) ? @response.status.to_i : @response[0]
+      end
+
+      def response_headers
+        @response.is_a?(::ActionController::Response) ? @response.headers.to_hash : @response[1]
+      end
+
+      def response_body_as_hash
+        @response_body_as_hash ||= YAML.load(response_body)
+      end
+    end
+  end
+end