searchgasm 0.9.10 → 1.0.0

data/CHANGELOG

@@ -1,3 +1,5 @@
+v1.0.0. Major changes in the helpers, they were completely re-engineered. Much nicer and cleaner now. I established a pattern between all helpers giving you complete flexibility as to how they are used. All helpers are called differently now (see documentation).
+
 v0.9.10. Hardened more tests, fixed bug with setting the per_page configuration to only take effect on protected searches, thus staying out of the way of normal searching.
 
 v0.9.9. Fixed setting per_page to nil, false, or ''. This is done to "show all" results.

data/Manifest

@@ -22,9 +22,16 @@ lib/searchgasm/condition/tree.rb
 lib/searchgasm/conditions/base.rb
 lib/searchgasm/conditions/protection.rb
 lib/searchgasm/config.rb
-lib/searchgasm/helpers/form_helper.rb
-lib/searchgasm/helpers/search_helper.rb
-lib/searchgasm/helpers/utilities_helper.rb
+lib/searchgasm/helpers/control_types/link.rb
+lib/searchgasm/helpers/control_types/links.rb
+lib/searchgasm/helpers/control_types/remote_link.rb
+lib/searchgasm/helpers/control_types/remote_links.rb
+lib/searchgasm/helpers/control_types/remote_select.rb
+lib/searchgasm/helpers/control_types/select.rb
+lib/searchgasm/helpers/control_types.rb
+lib/searchgasm/helpers/form.rb
+lib/searchgasm/helpers/utilities.rb
+lib/searchgasm/helpers.rb
 lib/searchgasm/search/base.rb
 lib/searchgasm/search/conditions.rb
 lib/searchgasm/search/ordering.rb

data/README.rdoc

@@ -84,19 +84,21 @@ Your view:
   
   %table
     %tr
-      %th= order_by :first_name
-      %th= order_by :last_name
-      %th= order_by :email
+      %th= order_by_link :account => :name
+      %th= order_by_link :first_name
+      %th= order_by_link :last_name
+      %th= order_by_link :email
     - @users.each do |user|
-      %tr
-        %td= user.first_name
-        %td= user.last_name
-        %td= user.email
+        %tr
+          %td= user.account? ? user.account.name : "-"
+          %td= user.first_name
+          %td= user.last_name
+          %td= user.email
   
   Per page:
-  = per_page
+  = per_page_select
   Page:
-  = pages
+  = page_select
 
 <b>{See my tutorial on this example}(http://www.binarylogic.com/2008/9/7/tutorial-pagination-ordering-and-searching-with-searchgasm)</b>
 
@@ -253,6 +255,8 @@ If there is one thing we all know, it's to always use protection against SQL inj
   search = Account.new_search!(params[:search])
   conditions = Account.new_conditions!(params[:conditions])
 
+I'm sure you already knew this, but it's tempting to do this when you can pass the params hash right into these methods.
+
 Lesson learned: use new\_search and new\_conditions when passing in params as *ANY* of the options.
 
 == Available Conditions

data/lib/searchgasm/config.rb

@@ -43,31 +43,6 @@ module Searchgasm
         @desc_indicator = value
       end
       
-      def pages_text # :nodoc:
-        @set_pages_text ? @pages_text : "Page %p"
-      end
-      
-      # The default value for the :text options in the pages helper.
-      #
-      # * <tt>Default:</tt> "Page %p"
-      # * <tt>Accepts:</tt> "Your string %p": where %p is replaced by the page number, or a block: Proc.new { |p| "Page #{p}" }
-      def pages_text=(value)
-        @set_pages_text = true
-        @pages_text
-      end
-      
-      def pages_type # :nodoc:
-        @pages_type ||= :select
-      end
-      
-      # The default value for the :type option in the pages helper.
-      #
-      # * <tt>Default:</tt> :select
-      # * <tt>Accepts:</tt> :select, :links
-      def pages_type=(value)
-        @pages_type = value.to_sym
-      end
-      
       def per_page # :nodoc:
         @per_page
       end
@@ -95,69 +70,17 @@ module Searchgasm
         @per_page_choices = value
       end
       
-      def per_page_type # :nodoc:
-        @per_page_type ||= :select
-      end
-      
-      # The default value for the :type option in the per_page helper.
-      #
-      # * <tt>Default:</tt> :select
-      # * <tt>Accepts:</tt> :select, :links
-      def per_page_type=(value)
-        @per_page_type = value.to_sym
-      end
-      
       def hidden_fields # :nodoc:
         @hidden_fields ||= (Search::Base::SPECIAL_FIND_OPTIONS - [:page])
       end
       
-      # Which hidden fields to automatically include when creating a form with a Searchgasm object. See Searchgasm::Helpers::FormHelper for more info.
+      # Which hidden fields to automatically include when creating a form with a Searchgasm object. See Searchgasm::Helpers::Form for more info.
       #
       # * <tt>Default:</tt> [:order_by, :order_as, :per_page]
       # * <tt>Accepts:</tt> Array, nil, false
       def hidden_fields=(value)
         @hidden_fields = value
       end
-      
-      def remote_helpers # :nodoc:
-        @remote_helpers ||= false
-      end
-      
-      # Tells all helpers to default to using remote links (AJAX) instead of normal links.
-      #
-      # * <tt>Default:</tt> false
-      # * <tt>Accepts:</tt> Boolean
-      #
-      # nil means "Show all"
-      def remote_helpers=(value)
-        @remote_helpers = value
-      end
-      
-      def remote_helpers? # :nodoc:
-        remote_helpers == true
-      end
-      
-      def search_scope # :nodoc:
-        
-      end
-      
-      def search_obj_name # :nodoc:
-        @search_obj_name ||= :@search
-      end
-      
-      # The instance variable name you use to assign your search to. This allows the helpers to grab your Searchgasm object without having
-      # to specify it everywhere.
-      #
-      # * <tt>Default:</tt> :@search
-      # * <tt>Accepts:</tt> String or Symbol.
-      #
-      # === Examples
-      #
-      #   config.search_obj_name = :@search
-      #   config.search_obj_name = "@search"
-      def search_obj_name=(value)
-        @search_obj_name = value
-      end
     end
   end
 end

data/lib/searchgasm/helpers/control_types/link.rb

@@ -0,0 +1,198 @@
+module Searchgasm
+  module Helpers
+    module ControlTypes
+      # = Link Control Types
+      #
+      # These helpers make ordering and paginating your data a breeze in your view. They only produce links.
+      module Link
+        # Creates a link for ordering data by a column or columns
+        #
+        # === Example uses for a User class that has many orders
+        #
+        #   order_by_link(:first_name)
+        #   order_by_link([:first_name, :last_name])
+        #   order_by_link({:orders => :total})
+        #   order_by_link([{:orders => :total}, :first_name])
+        #   order_by_link(:id, :text => "Order Number", :html => {:class => "order_number"})
+        #
+        # What's nifty about this is that the value gets "serialized", if it is not a string or a symbol, so that it can be passed via a param in the url. Searchgasm will automatically try to "unserializes" this value and use it. This allows you
+        # to pass complex objects besides strings and symbols, such as arrays and hashes. All of the hard work is done for you.
+        #
+        # Another thing to keep in mind is that this will alternate between "asc" and "desc" each time it is clicked.
+        #
+        # === Options
+        # * <tt>:text</tt> -- default: column_name.to_s.humanize, text for the link
+        # * <tt>:desc_indicator</tt> -- default: &nbsp;&#9660;, the indicator that this column is descending
+        # * <tt>:asc_indicator</tt> -- default: &nbsp;&#9650;, the indicator that this column is ascending
+        # * <tt>:html</tt> -- html arrtributes for the <a> tag.
+        #
+        # === Advanced Options
+        # * <tt>:params_scope</tt> -- default: :search, this is the scope in which your search params will be preserved (params[:search]). If you don't want a scope and want your options to be at base leve in params such as params[:page], params[:per_page], etc, then set this to nil.
+        # * <tt>:search_obj</tt> -- default: @#{params_scope}, this is your search object, everything revolves around this. It will try to infer the name from your params_scope. If your params_scope is :search it will try to get @search, etc. If it can not be inferred by this, you need to pass the object itself.
+        def order_by_link(order_by, options = {})
+          order_by = deep_stringify(order_by)
+          add_order_by_link_defaults!(order_by, options)
+          html = searchgasm_state_for(:order_by, options) + searchgasm_state_for(:order_as, options)
+          
+          if !options[:is_remote]
+            html += link_to(options[:text], options[:url], options[:html])
+          else
+            html += link_to_remote(options[:text], options[:remote].merge(:url => options[:url]), options[:html])
+          end
+          
+          html
+        end
+        
+        # Creates a link for ascending or descending data, pretty self e
+        #
+        # === Example uses
+        #
+        #   order_as_link("asc")
+        #   order_as_link("desc")
+        #   order_as_link("asc", :text => "Ascending", :html => {:class => "ascending"})
+        #
+        # === Options
+        # * <tt>:text</tt> -- default: column_name.to_s.humanize, text for the link
+        # * <tt>:html</tt> -- html arrtributes for the <a> tag.
+        #
+        # === Advanced Options
+        # * <tt>:params_scope</tt> -- default: :search, this is the scope in which your search params will be preserved (params[:search]). If you don't want a scope and want your options to be at base leve in params such as params[:page], params[:per_page], etc, then set this to nil.
+        # * <tt>:search_obj</tt> -- default: @#{params_scope}, this is your search object, everything revolves around this. It will try to infer the name from your params_scope. If your params_scope is :search it will try to get @search, etc. If it can not be inferred by this, you need to pass the object itself.
+        def order_as_link(order_as, options = {})
+          add_order_as_link_defaults!(order_as, options)
+          html = searchgasm_state_for(:order_as, options)
+          
+          if !options[:is_remote]
+            html += link_to(options[:text], options[:url], options[:html])
+          else
+            html += link_to_remote(options[:text], options[:remote].merge(:url => options[:url]), options[:html])
+          end
+          
+          html
+        end
+        
+        # Creates a link for limiting how many items are on each page
+        #
+        # === Example uses
+        #
+        #   per_page_link(200)
+        #   per_page_link(nil) # => Show all
+        #   per_page_link(nil, :text => "All", :html => {:class => "show_all"})
+        #
+        # As you can see above, passing nil means "show all" and the text will automatically revert to "show all"
+        #
+        # === Options
+        # * <tt>:text</tt> -- default: column_name.to_s.humanize, text for the link
+        # * <tt>:html</tt> -- html arrtributes for the <a> tag.
+        #
+        # === Advanced Options
+        # * <tt>:params_scope</tt> -- default: :search, this is the scope in which your search params will be preserved (params[:search]). If you don't want a scope and want your options to be at base leve in params such as params[:page], params[:per_page], etc, then set this to nil.
+        # * <tt>:search_obj</tt> -- default: @#{params_scope}, this is your search object, everything revolves around this. It will try to infer the name from your params_scope. If your params_scope is :search it will try to get @search, etc. If it can not be inferred by this, you need to pass the object itself.
+        def per_page_link(per_page, options = {})
+          add_per_page_link_defaults!(per_page, options)
+          html = searchgasm_state_for(:per_page, options)
+          
+          if !options[:is_remote]
+            html += link_to(options[:text], options[:url], options[:html])
+          else
+            html += link_to_remote(options[:text], options[:remote].merge(:url => options[:url]), options[:html])
+          end
+          
+          html
+        end
+        
+        # Creates a link for changing to a sepcific page of your data
+        #
+        # === Example uses
+        #
+        #   page_link(2)
+        #   page_link(1)
+        #   page_link(5, :text => "Fifth page", :html => {:class => "fifth_page"})
+        #
+        # === Options
+        # * <tt>:text</tt> -- default: column_name.to_s.humanize, text for the link
+        # * <tt>:html</tt> -- html arrtributes for the <a> tag.
+        #
+        # === Advanced Options
+        # * <tt>:params_scope</tt> -- default: :search, this is the scope in which your search params will be preserved (params[:search]). If you don't want a scope and want your options to be at base leve in params such as params[:page], params[:per_page], etc, then set this to nil.
+        # * <tt>:search_obj</tt> -- default: @#{params_scope}, this is your search object, everything revolves around this. It will try to infer the name from your params_scope. If your params_scope is :search it will try to get @search, etc. If it can not be inferred by this, you need to pass the object itself.
+        def page_link(page, options = {})
+          add_page_link_defaults!(page, options)
+          html = searchgasm_state_for(:page, options)
+          
+          if !options[:is_remote]
+            html += link_to(options[:text], options[:url], options[:html])
+          else
+            html += link_to_remote(options[:text], options[:remote].merge(:url => options[:url]), options[:html])
+          end
+          
+          html
+        end
+        
+        private
+          def add_order_by_link_defaults!(order_by, options = {})
+            add_searchgasm_helper_defaults!(:order_by, options)
+            options[:text] ||= determine_order_by_text(order_by)
+            options[:asc_indicator] ||= Config.asc_indicator
+            options[:desc_indicator] ||= Config.desc_indicator
+            options[:text] += options[:search_obj].desc? ? options[:desc_indicator] : options[:asc_indicator] if options[:search_obj].order_by == order_by
+            url_hash = searchgasm_url_hash(:order_by, order_by, options)
+            url_hash[:order_as] = (options[:search_obj].order_by == order_by && options[:search_obj].asc?) ? "DESC" : "ASC"
+            options[:url] = searchgasm_url(url_hash, options)
+            options
+          end
+          
+          def add_order_as_link_defaults!(order_as, options = {})
+            add_searchgasm_helper_defaults!(:order_as, options)
+            options[:text] ||= order_as.to_s
+            options[:url] = searchgasm_url(searchgasm_url_hash(:order_as, order_as, options), options)
+            options
+          end
+          
+          def add_per_page_link_defaults!(per_page, options = {})
+            add_searchgasm_helper_defaults!(:per_page, options)
+            options[:text] ||= per_page.blank? ? "Show all" : "#{per_page} per page"
+            options[:url] = searchgasm_url(searchgasm_url_hash(:per_page, per_page, options), options)
+            options
+          end
+          
+          def add_page_link_defaults!(page, options = {})
+            add_searchgasm_helper_defaults!(:page, options)
+            options[:text] ||= page.to_s
+            options[:url] = searchgasm_url(searchgasm_url_hash(:page, page, options), options)
+            options
+          end
+          
+          def determine_order_by_text(column_name, relationship_name = nil)
+            case column_name
+            when String, Symbol
+              relationship_name.blank? ? column_name.to_s.titleize : "#{relationship_name.to_s.titleize} #{column_name.to_s.titleize}"
+            when Array
+              determine_order_by_text(column_name.first)
+            when Hash
+              k = column_name.keys.first
+              v = column_name.values.first
+              determine_order_by_text(v, k)
+            end
+          end
+          
+          def deep_stringify(obj)
+            case obj
+            when String
+              obj
+            when Symbol
+              obj = obj.to_s
+            when Array
+              obj = obj.collect { |item| deep_stringify(item) }
+            when Hash
+              new_obj = {}
+              obj.each { |key, value| new_obj[key.to_s] = deep_stringify(value) }
+              new_obj
+            end
+          end
+      end
+    end
+  end
+end
+
+ActionController::Base.helper Searchgasm::Helpers::ControlTypes::Link if defined?(ActionController)

data/lib/searchgasm/helpers/control_types/links.rb

@@ -0,0 +1,149 @@
+module Searchgasm
+  module Helpers
+    module ControlTypes
+      module Links
+        # Creates a group of links that order the data by a column or columns. All that this does is loop through the :choices option and call order_by_link and then glue it all together.
+        #
+        # === Examples
+        #
+        #   order_by_links
+        #   order_by_links(:choices => [:name, {:orders => {:line_items => :total}}, :email])
+        #
+        # === Options
+        #
+        # Please look at order_by_link. All options there are applicable here and are passed onto each option.
+        #
+        # * <tt>:choices</tt> -- default: the models column names, the choices to loop through when calling order_by_link
+        def order_by_links(options = {})
+          add_order_by_links_defaults!(options)
+          link_options = options.dup
+          link_options.delete(:choices)
+          html = ""
+          options[:choices].each { |choice| html += order_by_link(choice, link_options.dup) }
+          html
+        end
+        
+        # Creates a group of links that ascend or descend the data. All that this does is loop through the :choices option and call order_as_link and then glue it all together.
+        #
+        # === Examples
+        #
+        #   order_as_links
+        #   order_as_links(:choices => [:ascending, :descending])
+        #
+        # === Options
+        #
+        # Please look at order_as_link. All options there are applicable here and are passed onto each option.
+        #
+        # * <tt>:choices</tt> -- default: ["asc", "desc"], the choices to loop through when calling order_as_link
+        def order_as_links(options = {})
+          add_order_as_links_defaults!(options)
+          link_options = options.dup
+          link_options.delete(:choices)
+          html = ""
+          options[:choices].each { |choice| html += order_as_link(choice, link_options.dup) }
+          html
+        end
+        
+        # Creates a group of links that limit how many items are on each page. All that this does is loop through the :choices option and call per_page_link and then glue it all together.
+        #
+        # === Examples
+        #
+        #   per_page_links
+        #   per_page_links(:choices => [25, 50, nil])
+        #
+        # === Options
+        #
+        # Please look at per_page_link. All options there are applicable here and are passed onto each option.
+        #
+        # * <tt>:choices</tt> -- default: [10, 25, 50, 100, 150, 200, nil], the choices to loop through when calling per_page_link.
+        def per_page_links(options = {})
+          add_per_page_links_defaults!(options)
+          link_options = options.dup
+          link_options.delete(:choices)
+          html = ""
+          options[:choices].each { |choice| html += per_page_link(choice, link_options.dup) }
+          html
+        end
+        
+        # Creates a group of links that paginate through the data. Kind of like a flickr page navigation. This one has some nifty options.
+        #
+        # === Examples
+        #
+        #   page_links
+        #   page_links(:choices => [25, 50, nil])
+        #
+        # === Options
+        #
+        # Please look at per_page_link. All options there are applicable here and are passed onto each option.
+        #
+        # * <tt>:spread</tt> -- default: 3, how many choices available on each side of the current page
+        # * <tt>:prev</tt> -- default: <, set to nil to omit. This is an extra link on the left side of the page links that will go to the previous page
+        # * <tt>:next</tt> -- default: >, set to nil to omit. This is an extra link on the right side of the page links that will go to the next page
+        # * <tt>:first</tt> -- default: <<, set to nil to omit. This is an extra link on thefar left side of the page links that will go to the first page
+        # * <tt>:last</tt> -- default: >>, set to nil to omit. This is an extra link on the far right side of the page links that will go to the last page
+        def page_links(options = {})
+          add_page_links_defaults!(options)
+          
+          current_page = options[:search_obj].page
+          page_start = 0
+          page_end = 0
+          if !options[:spread].blank?
+            page_start = current_page - options[:spread]
+            page_start = options[:choices].first unless options[:choices].include?(page_start)
+            page_end = current_page + options[:spread]
+            page_end = options[:choices].last unless options[:choices].include?(page_end)
+          else
+            page_start = options[:choices].first
+            page_end = options[:choices].last
+          end
+          
+          
+          link_options = options.dup
+          [:choices, :spread, :prev, :next, :first, :last].each { |option| link_options.delete(option) }
+          html = ""
+          (page_start..page_end).each { |choice| html += page_link(choice, link_options.dup) }
+          html
+        end
+        
+        private
+          def add_order_by_links_defaults!(options)
+            add_searchgasm_helper_defaults!(:order_by, options)
+            options[:choices] ||= options[:search_obj].klass.column_names.map(&:humanize)
+            options
+          end
+          
+          def add_order_as_links_defaults!(options)
+            add_searchgasm_helper_defaults!(:order_as, options)
+            options[:choices] = [:asc, :desc]
+            options
+          end
+          
+          def add_per_page_links_defaults!(options)
+            add_searchgasm_helper_defaults!(:per_page, options)
+            options[:choices] ||= Config.per_page_choices.dup
+            if !options[:search_obj].per_page.blank? && !options[:choices].include?(options[:search_obj].per_page)
+              options[:choices] << options[:search_obj].per_page
+              has_nil = options[:choices].include?(nil)
+              options[:choices].compact!
+              options[:choices].sort!
+              options[:choices] << nil if has_nil
+            end
+            options
+          end
+          
+          def add_page_links_defaults!(options)
+            add_searchgasm_helper_defaults!(:page, options)
+            options[:choices] ||= (1..options[:search_obj].page_count)
+            options[:spead] ||= 3
+            options[:prev] ||= "<"
+            options[:next] ||= ">"
+            options[:first] ||= "<<"
+            options[:last] ||= ">>"
+            options
+          end
+      end
+    end
+  end
+end
+
+ActionController::Base.helper Searchgasm::Helpers::ControlTypes::Links if defined?(ActionController)

data/lib/searchgasm/helpers/control_types/remote_link.rb

@@ -0,0 +1,86 @@
+module Searchgasm
+  module Helpers
+    module ControlTypes
+      # = Remote Link Control Types
+      #
+      # These helpers use rails built in remote_function as links.
+      module RemoteLink
+        # The same thing as order_by_link but instead of using rails link_to it uses link_to_remote
+        #
+        # === Examples
+        #
+        #   remote_order_by_link
+        #   remote_order_by_link(:remote => {:update => "users"})
+        #
+        # === Options
+        #
+        # Please look at order_by_link, this accepts the same options with the following addition:
+        #
+        # * <tt>:remote</tt> -- default: {}, the options to pass into link_to_remote remote options. Such as :update => {:success => "alert('success')"}
+        def remote_order_by_link(order_by, options = {})
+          add_remote_defaults!(options)
+          order_by_link(order_by, options)
+        end
+        
+        # The same thing as order_as_link but instead of using rails link_to it uses link_to_remote
+        #
+        # === Examples
+        #
+        #   remote_order_as_link
+        #   remote_order_as_link(:remote => {:update => "users"})
+        #
+        # === Options
+        #
+        # Please look at order_as_link, this accepts the same options with the following addition:
+        #
+        # * <tt>:remote</tt> -- default: {}, the options to pass into link_to_remote remote options. Such as :update => {:success => "alert('success')"}
+        def remote_order_as_link(order_as, options = {})
+          add_remote_defaults!(options)
+          order_as_link(order_as, options)
+        end
+        
+        # The same thing as per_page_link but instead of using rails link_to it uses link_to_remote
+        #
+        # === Examples
+        #
+        #   remote_per_page_link
+        #   remote_per_page_link(:remote => {:update => "users"})
+        #
+        # === Options
+        #
+        # Please look at per_page_link, this accepts the same options with the following addition:
+        #
+        # * <tt>:remote</tt> -- default: {}, the options to pass into link_to_remote remote options. Such as :update => {:success => "alert('success')"}
+        def remote_per_page_link(per_page, options = {})
+          add_remote_defaults!(options)
+          per_page_link(per_page, options)
+        end
+        
+        # The same thing as page_link but instead of using rails link_to it uses link_to_remote
+        #
+        # === Examples
+        #
+        #   remote_page_link
+        #   remote_page_link(:remote => {:update => "users"})
+        #
+        # === Options
+        #
+        # Please look at page_link, this accepts the same options with the following addition:
+        #
+        # * <tt>:remote</tt> -- default: {}, the options to pass into link_to_remote remote options. Such as :update => {:success => "alert('success')"}
+        def remote_page_link(page, options = {})
+          add_remote_defaults!(options)
+          page_link(page, options)
+        end
+        
+        private
+          def add_remote_defaults!(options)
+            options[:remote] ||= {}
+            options[:is_remote] = true
+          end
+      end
+    end
+  end
+end
+
+ActionController::Base.helper Searchgasm::Helpers::ControlTypes::RemoteLink if defined?(ActionController)

data/lib/searchgasm/helpers/control_types/remote_links.rb

@@ -0,0 +1,69 @@
+module Searchgasm
+  module Helpers
+    module ControlTypes
+      module RemoteLinks
+        # Same as order_by_links, but uses link_to_remote instead of remote.
+        #
+        # === Examples
+        #
+        #   remote_order_by_links
+        #   remote_order_by_links(:remote => {:update => "users"})
+        #
+        # === Options
+        #
+        # Please look at remote_order_by_link and order_by_links. All options there are applicable here. This is just a wrapper method for those 2 methods.
+        def remote_order_by_links(options = {})
+          add_remote_defaults!(options)
+          order_by_links(options)
+        end
+        
+        # Same as order_as_links, but uses link_to_remote instead of remote.
+        #
+        # === Examples
+        #
+        #   remote_order_as_links
+        #   remote_order_as_links(:remote => {:update => "users"})
+        #
+        # === Options
+        #
+        # Please look at remote_order_as_link and order_as_links. All options there are applicable here. This is just a wrapper method for those 2 methods.
+        def remote_order_as_links(options = {})
+          add_remote_defaults!(options)
+          order_as_link(options)
+        end
+        
+        # Same as per_page_links, but uses link_to_remote instead of remote.
+        #
+        # === Examples
+        #
+        #   remote_per_page_links
+        #   remote_per_page_links(:remote => {:update => "users"})
+        #
+        # === Options
+        #
+        # Please look at remote_per_page_link and per_page_links. All options there are applicable here. This is just a wrapper method for those 2 methods.
+        def remote_per_page_links(options = {})
+          add_remote_defaults!(options)
+          per_page_links(options)
+        end
+        
+        # Same as page_links, but uses link_to_remote instead of remote.
+        #
+        # === Examples
+        #
+        #   remote_page_links
+        #   remote_page_links(:remote => {:update => "users"})
+        #
+        # === Options
+        #
+        # Please look at remote_page_link and page_links. All options there are applicable here. This is just a wrapper method for those 2 methods.
+        def remote_page_links(options = {})
+          add_remote_defaults!(options)
+          page_links(options)
+        end
+      end
+    end
+  end
+end
+
+ActionController::Base.helper Searchgasm::Helpers::ControlTypes::RemoteLinks if defined?(ActionController)