jqgrid_rails 1.2.0

data/lib/jqgrid_rails/jqgrid_rails_controller.rb

@@ -0,0 +1,286 @@
+module JqGridRails
+  module Controller
+    
+    # These are the valid search operators jqgrid uses
+    # and the database translations for them. We use closures
+    # for the value so we can modify the string if we see fit
+    SEARCH_OPERS = {
+      'eq' => ['= ?', lambda{|v|v}],
+      'ne' => ['!= ?', lambda{|v|v}],
+      'lt' => ['< ?', lambda{|v|v}],
+      'le' => ['<= ?', lambda{|v|v}],
+      'gt' => ['> ?', lambda{|v|v}],
+      'ge' => ['>= ?', lambda{|v|v}],
+      'bw' => ['ilike ?', lambda{|v| "#{v}%"}],
+      'bn' => ['not ilike ?', lambda{|v| "#{v}%"}],
+      'in' => ['in ?', lambda{|v| v.split(',').map(&:strip)}],
+      'ni' => ['not in ?', lambda{|v| v.split(',').map(&:strip)}],
+      'ew' => ['ilike ?', lambda{|v| "%#{v}"}],
+      'en' => ['not ilike ?', lambda{|v| "%#{v}"}],
+      'cn' => ['ilike ?', lambda{|v| "%#{v}%"}],
+      'nc' => ['not ilike ?', lambda{|v| "%#{v}%"}]
+    }
+
+    # klass:: ActiveRecord::Base class or ActiveRecord::Relation
+    # params:: Request params
+    # fields:: Fields used within grid. Can be an array of attribute names or a Hash with keys of attributes and Hash values with options
+    #   Array: [col1, col2, col3]
+    #   Hash: {'col1' => {:fomatter => lambda{|v|v.to_s.upcase}, :order => 'other_table.col1'}}
+    # Provides generic JSON response for jqGrid requests (sorting/searching)
+    def grid_response(klass, params, fields)
+      raw_response(klass, params, fields).to_json
+    end
+
+    # klass:: ActiveRecord::Base class or ActiveRecord::Relation
+    # params:: Request params
+    # fields:: Fields used within grid. Can be an array of attribute names or a Hash with keys of attributes and Hash values with options
+    #   Array: [col1, col2, col3]
+    #   Hash: {'col1' => {:fomatter => lambda{|v|v.to_s.upcase}, :order => 'other_table.col1'}}
+    # Provides hash result for jqGrid requests (sorting/searching)
+    def raw_response(klass, params, fields)
+      allowed_consts = %w(ActiveRecord::Base ActiveRecord::Relation ActiveRecord::NamedScope::Scope)
+      unless(allowed_consts.detect{|const| klass.ancestors.detect{|c| c.to_s == const}})
+        raise TypeError.new "Unexpected type received. Allowed types are Class or ActiveRecord::Relation. Received: #{klass.class.name}"
+      end
+      clean_fields = scrub_fields(fields)
+      rel = apply_searching(klass, params, clean_fields)
+      unsorted = apply_filtering(rel, params, clean_fields)
+      rel = apply_sorting(unsorted, params, clean_fields)
+      create_result_hash(unsorted, rel, clean_fields)
+    end
+
+    # fields:: Fields used within grid
+    # Scrubs out fields to ensure in proper state
+    def scrub_fields(fields)
+      clean_fields = nil
+      if(fields.is_a?(Hash))
+        clean_fields = ActiveSupport::OrderedHash.new
+        fields.each_pair do |k,v|
+          clean_fields[k.to_s] = v.nil? ? {} : v
+        end
+      else
+        clean_fields = fields.map(&:to_s)
+      end
+      if(clean_fields.is_a?(Hash))
+        raise TypeError.new 'Hash values must be of Hash type or nil' if fields.values.detect{|v| !v.is_a?(Hash)}
+      end
+      clean_fields
+    end
+
+    # given:: Field for searching
+    # fields:: Array or Hash map of fields
+    # Returns proper field if mapped and ensures field is valid
+    def discover_field(given, fields)
+      given = JqGridRails.unescape(given)
+      col = nil
+      case fields
+        when Hash
+          col = fields.keys.detect{|key| key.to_s == given}
+        when Array
+          col = given if fields.map(&:to_s).include?(given)
+        else
+          raise TypeError.new "Expecting fields to be Array or Hash. Received: #{fields.class.name}"
+      end
+      raise NameError.new "Requested field was not found in provided fields list. Given: #{given}" unless col
+      col
+    end
+
+    # klass:: ActiveRecord::Base class or ActiveRecord::Relation
+    # col:: Sort column
+    # fields:: Aray or Hash map of fields
+    # Returns proper sorter based on inference or user defined
+    def discover_sorter(klass, col, fields)
+      col = JqGridRails.unescape(col)
+      if(fields.is_a?(Hash) && fields[col].try(:[], :order).present?)
+        fields[col][:order]
+      else
+        database_name_by_string(col, klass, fields)
+      end
+    end
+
+
+
+    # klass:: ActiveRecord::Base class or ActiveRecord::Relation
+    # params:: Request params
+    # fields:: Fields used within grid
+    # Applies any sorting to result set
+    def apply_sorting(klass, params, fields)
+      sort_col = params[[:sidx, :searchField].find{|sym| !params[sym].blank?}]
+      unless(sort_col)
+        begin
+          sort_col = discover_field(sort_col, fields)
+        rescue NameError
+          # continue on and let the sort_col be set to default below
+        end
+      end
+      unless(sort_col)
+        sort_col = (fields.is_a?(Hash) ? fields.keys : fields).first
+      end
+      sorter = discover_sorter(klass, sort_col, fields)
+      sort_ord = params[:sord] == 'asc' ? 'ASC' : 'DESC'
+      if(sorter.present?)
+        if(defined?(ActiveRecord::Relation) && klass.is_a?(ActiveRecord::Relation))
+          klass.order("#{sorter} #{sort_ord}")
+        else
+          klass.scoped(:order => "#{sorter} #{sort_ord}")
+        end
+      else
+        klass
+      end
+    end
+    
+    # klass:: ActiveRecord::Base class or ActiveRecord::Relation
+    # params:: Request params
+    # fields:: Fields used within grid
+    # Applies any search restrictions to result set
+    # TODO: DRY out #apply_filtering and #apply_searching
+    def apply_searching(klass, params, fields)
+      unless(params[:searchField].blank?)
+        field = discover_field(params[:searchField], fields)
+        search_oper = params[:searchOper]
+        search_string = params[:searchString]
+        raise ArgumentError.new("Invalid search operator received: #{search_oper}") unless SEARCH_OPERS.keys.include?(search_oper)
+        if(defined?(ActiveRecord::Relation) && klass.is_a?(ActiveRecord::Relation))
+          if(fields.is_a?(Hash) && fields[field][:having])
+            rel = rel.having([
+              "#{fields[field][:having]} #{SEARCH_OPERS[oper].first}", SEARCH_OPERS[oper].last.call(data)
+            ])
+          end
+          if(!fields.is_a?(Hash) || fields[field][:having].blank? || fields[field][:where])
+            klass.where([
+              "#{database_name_by_string(field, klass, fields)} #{SEARCH_OPERS[search_oper].first}",
+              SEARCH_OPERS[search_oper].last.call(search_string)
+            ])
+          end
+        else
+          if(fields.is_a?(Hash) && fields[field][:having])
+            rel = rel.scoped(
+              :conditions => [
+                "#{fields[field][:having]} #{SEARCH_OPERS[oper].first}", SEARCH_OPERS[oper].last.call(data)
+              ]
+            )
+          end
+          if(!fields.is_a?(Hash) || fields[field][:having].blank? || fields[field][:where])
+            klass.scoped(
+              :conditions => [
+                "#{database_name_by_string(field, klass, fields)} #{SEARCH_OPERS[search_oper].first}",
+                SEARCH_OPERS[search_oper].last.call(search_string)
+              ]
+            )
+          end
+        end
+      else
+        klass
+      end
+    end
+
+    # klass:: ActiveRecord::Base class or ActiveRecord::Relation
+    # params:: Request params
+    # fields:: Fields used within grid
+    # Applies any filter restrictions to result set
+    #
+    # TODO: Currently this only supports AND'ing the filters. Need 
+    # to add support for grabbing groupOp from parameters and using it for
+    # joining query parameters. 
+    def apply_filtering(klass, params, fields)
+      rel = klass
+      havings = []
+      unless(params[:filters].blank?)
+        filters = JSON.load(params[:filters])
+        filters['rules'].each do |filter|
+          field = discover_field(filter['field'].gsub('___', '.'), fields)
+          oper = filter['op']
+          raise ArgumentError.new("Invalid search operator received: #{oper}") unless SEARCH_OPERS.keys.include?(oper)
+          data = filter['data']
+          if(fields.is_a?(Hash) && fields[field][:having])
+            havings << ["#{fields[field][:having]} #{SEARCH_OPERS[oper].first}", SEARCH_OPERS[oper].last.call(data)]
+          end
+          if(defined?(ActiveRecord::Relation) && rel.is_a?(ActiveRecord::Relation))
+            if(!fields.is_a?(Hash) || fields[field][:having].blank? || fields[field][:where])
+              rel = rel.where([
+                "#{database_name_by_string(field, klass, fields)} #{SEARCH_OPERS[oper].first}",
+                SEARCH_OPERS[oper].last.call(data)
+              ])
+            end
+          else
+            if(!fields.is_a?(Hash) || fields[field][:having].blank? || fields[field][:where])
+              rel = rel.scoped(
+                :conditions => [
+                  "#{database_name_by_string(field, klass, fields)} #{SEARCH_OPERS[oper].first}",
+                  SEARCH_OPERS[oper].last.call(data)
+                ]
+              )
+            end
+          end
+        end
+      end
+      unless(havings.blank?)
+        ary = ["(#{havings.map(&:first).join(') AND (')})", *havings.map(&:last)]
+        rel = defined?(ActiveRecord::Relation) && rel.is_a?(ActiveRecord::Relation) ? rel.having(ary) : rel.scoped(:having => ary)
+      end
+      rel
+    end
+
+    # klass:: ActiveRecord::Base class or ActiveRecord::Relation
+    # fields:: Fields used within grid
+    # Creates a result Hash in the structure the grid is expecting
+    # TODO: Calling #length is less than ideal on large datasets, but it is needed
+    # for cases where we are grouping items up for results. Perhaps set an optional
+    # flag to enable #length usage and use #count by default
+    def create_result_hash(unsorted, klass, fields)
+      if(defined?(ActiveRecord::Relation) && klass.is_a?(ActiveRecord::Relation))
+        dbres = klass.limit(params[:rows].to_i).offset(params[:rows].to_i * (params[:page].to_i - 1)).all
+        if(unsorted.respond_to?(:group_values) && unsorted.group_values.size > 0)
+          total = klass.connection.execute("SELECT COUNT(*) as count from (#{unsorted.to_sql}) AS countable_query").map.first['count'].to_i
+        end
+      else
+        dbres = klass.find(:all, :limit => params[:rows], :offset => (params[:rows].to_i * (params[:page].to_i - 1)))
+        if(unsorted.respond_to?(:proxy_options) && unsorted.proxy_options[:group].present?)
+          total = klass.connection.execute("SELECT COUNT(*) as count from (#{unsorted.send(:construct_finder_sql, {})}) AS countable_query").map.first['count'].to_i
+        end
+      end
+      total = unsorted.count unless total
+      rows = params[:rows].to_i
+      total_pages = rows > 0 ? (total.to_f / rows).ceil : 0
+      res = {'total' => total_pages, 'page' => params[:page], 'records' => total}
+      calls = fields.is_a?(Array) ? fields : fields.is_a?(Hash) ? fields.keys : nil
+      maps = fields.is_a?(Hash) ? fields : nil
+      res['rows'] = dbres.map do |row|
+        hsh = {}
+        calls.each do |method|
+          value = method.to_s.split('.').inject(row) do |result,meth|
+            if(result.try(:respond_to?, meth))
+              result.send(meth)
+            else
+              nil
+            end
+          end
+          if(fields.is_a?(Hash) && fields[method][:formatter].is_a?(Proc))
+            value = fields[method][:formatter].call(value, row)
+          end
+          hsh[method] = value
+        end
+        hsh
+      end
+      res
+    end
+    
+    private
+
+    def database_name_by_string(string, klass, fields)
+      if(fields.is_a?(Hash) && fields[string].try(:[], :where))
+        fields[string][:where]
+      else
+        parts = string.split('.')
+        if(parts.size > 1)
+          parts = parts[-2,2]
+          "#{parts.first.pluralize}.#{parts.last}"
+        else
+          "#{klass.table_name}.#{parts.first}"
+        end
+      end
+    end
+  end
+end
+
+ActionController::Base.send :include, JqGridRails::Controller

data/lib/jqgrid_rails/jqgrid_rails_generators.rb

@@ -0,0 +1,23 @@
+module JqGridRails
+  module Generators
+
+    # grid:: JqGridRails::JqGrid instance
+    # Outputs javascript to build grid
+    def jq_grid(grid)
+      self << grid.build
+    end
+    alias_method :jqgrid, :jq_grid
+
+    # dom_id:: DOM ID of grid
+    # Instructs grid to reload itself
+    def reload_grid(dom_id)
+      dom_id = "##{dom_id}" unless dom_id.start_with?('#')
+      self << "jQuery('#{dom_id}').trigger('reloadGrid');"
+    end
+
+  end 
+end
+
+if(defined?(ActionView::Helpers::PrototypeHelper::JavaScriptGenerator::GeneratorMethods))
+  ActionView::Helpers::PrototypeHelper::JavaScriptGenerator::GeneratorMethods.send :include, JqGridRails::Generators
+end

data/lib/jqgrid_rails/jqgrid_rails_helper.rb

@@ -0,0 +1,12 @@
+require 'jqgrid_rails/jqgrid_rails_helpers'
+
+module JqGridRails
+  class Helper
+    include ActionView::Helpers::JavaScriptHelper
+    include JqGridRails::Helpers
+    attr_accessor :table_id
+    def initialize(dom_id)
+      @table_id = dom_id
+    end
+  end
+end

data/lib/jqgrid_rails/jqgrid_rails_helpers.rb

@@ -0,0 +1,250 @@
+#TODO: :with_row option is currently only applied to remote calls. Needs to be updated
+#      for non-ajax calls by adding dynamic form updates to include inputs for row data
+require 'rails_javascript_helpers'
+require 'action_view/helpers/form_tag_helper'
+
+module JqGridRails
+  module Helpers
+    include RailsJavaScriptHelpers
+
+    # id:: String or RawJS object
+    # Ensures a DOM ID is returned from id. Does simple
+    # string replacement client side to force a # prefix.
+    # Client side conversion allows the id to be a RawJS
+    # instance for dynamic grid IDs
+    def convert_dom_id(id)
+      RawJS.new("#{format_type_to_js(id)}.replace(/^#*/, '#')")
+    end
+
+    # hash:: Argument hash for callback generation
+    # Generates a javascript callback from a Ruby hash. Important hash keys:
+    # :build_callback -> [false|:item|:selection] (false will stop callback from being created and simply return original hash)
+    # :url            -> Symbol of route method name or string for actual url
+    # :args           -> Arguments to be used when generating URL from :url value
+    # :method         -> Request method (defaults to 'get')
+    # :ajax_args      -> Arguments for jQuery.ajax options hash
+    # :remote         -> [true|false] Request should be made via ajax
+    # :id_replacement -> Value used for dynamic ID replacement (generally not to be altered)
+    # :item_id        -> Use for :item type callbacks to set URL generated ID if not the generic 'id' variable
+    def hash_to_callback(hash)
+      if(hash.is_a?(Hash) && hash[:build_callback] != false && hash[:url])
+        case hash[:build_callback]
+        when :item
+          build_single_callback(hash)
+        when :selection
+          build_selection_callback(hash)
+        else
+          build_default_callback(hash)
+        end
+      else
+        hash
+      end
+    end
+
+    # hash:: Argument hash
+    # Extracts and formats argument hash for callbacks
+    def extract_callback_variables(hash)
+      @url_gen ||= JqGridRails::UrlGenerator.new
+      args = hash.dup
+      args[:ajax_args] = hash.delete(:ajax) || {}
+      args[:method] = args[:ajax_args][:type] || args[:ajax_args].delete(:method) || hash.delete(:method) || 'get'
+      if(hash[:url].is_a?(Symbol))
+        url_args = hash[:args].is_a?(Array) ? hash[:args] : [hash[:args]]
+        args[:url] = @url_gen.send(hash[:url], *(url_args.sort_by{|x,y| if(x.is_a?(Hash) && y.is_a?(Hash)) then 0 elsif(x.is_a?(Hash)) then 1 else -1 end}))
+      else
+        args[:url] = hash[:url]
+      end
+      if(hash[:args_replacements].present?)
+        if(hash[:args_replacements].is_a?(Hash))
+          args[:args_replacements] = hash[:args_replacements].map{|fake_id, js_id| "replace(#{format_type_to_js(fake_id)}, #{format_type_to_js(js_id)})" }.join('.')
+          unless(args[:args_replacements].blank?)
+            args[:args_replacements] = ".#{args[:args_replacements]}"
+          end
+        else
+          args[:args_replacements] = hash[:args_replacements]
+        end
+      end
+      args[:ajax_args][:type] = args[:method] if hash[:remote]
+      args
+    end
+
+    # hash:: Argument hash
+    # Builds callback function for single selection
+    def build_single_callback(hash)
+      hash[:id_replacement] ||= '000'
+      hash[:args] = Array(hash[:args]) unless hash[:args].is_a?(Array)
+      hash[:args].push hash[:id_replacement]
+      args = extract_callback_variables(hash)
+      confirm = args.delete(:confirm)
+      item_id = args[:item_id].present? ? args[:item_id] : RawJS.new('id')
+      if(hash[:remote])
+        if(hash[:with_row])
+          args[:ajax_args] ||= {}
+          args[:ajax_args][:data] = {:row_data => RawJS.new("jQuery(#{convert_dom_id(@table_id)}).jqGrid('getRowData', id)")}
+        end
+        " function(id){
+            #{confirm_if_required(
+              confirm,
+              "jQuery.ajax(#{format_type_to_js(args[:url])}.replace(#{format_type_to_js(args[:id_replacement])}, #{format_type_to_js(item_id)})#{args[:args_replacements]}, #{format_type_to_js(args[:ajax_args])});"
+            )}
+          }
+        "
+      else
+        form_rand = rand(999)
+        " function(id){
+            #{csrf_token_discovery(args[:method])}
+            #{confirm_if_required(
+              confirm,
+              "jQuery('body').append('<form id=\"redirector_#{form_rand}\" action=\"#{args[:url]}\" method=\"#{args[:method]}\">'.replace(#{format_type_to_js(args[:id_replacement])}, #{format_type_to_js(item_id)})#{args[:args_replacements]} + csrf_token +'</form>');
+              jQuery('#redirector_#{form_rand}').submit();"
+            )}
+          }
+        "
+      end
+    end
+
+    # Returns callable function to get current selection in array form
+    def selection_array(error_when_empty=true, table_id=nil)
+      dom_id = convert_dom_id(table_id || @table_id)
+      " function(){ 
+          ary = jQuery(#{dom_id}).jqGrid('getGridParam', 'selarrrow');
+          if(!ary.length){ ary = []; }
+          ary.push(jQuery(#{dom_id}).jqGrid('getGridParam', 'selrow'));
+          ary = jQuery.grep(ary, function(value,key){ return value != null && value.length && jQuery.inArray(value, ary) === key; });
+          if(!ary.length && #{format_type_to_js(error_when_empty)}){
+            alert('Please select items from the table first.');
+          }
+          return ary;
+        }
+      "
+    end
+
+    # hash:: Argument has
+    # Builds callback function for full selection
+    # NOTE: In general you will want the URL to be auto generated within jqgrid_rails. The route
+    # should accept an ID which will be the first ID of the current selection. An extra parameter named
+    # 'ids' will be provided which will be an array of all selected values, included the ID given
+    # to the route
+    def build_selection_callback(hash, table_id=nil)
+      dom_id = table_id || @table_id
+      hash[:id_replacement] ||= '000'
+      hash[:args] = Array(hash[:args]) unless hash[:args].is_a?(Array)
+      hash[:args].push hash[:id_replacement]
+      args = extract_callback_variables(hash)
+      confirm = args.delete(:confirm)
+      item_id = args[:item_id].present? ? args[:item_id] : RawJS.new('id')
+      function = "function(){ 
+        rows_func = #{selection_array(true, table_id)} 
+        ary = rows_func();
+        if(!ary.length){ return false; }
+      "
+      if(hash[:remote])
+        args[:ajax_args][:data] = {item_id.to_s.pluralize.to_sym => RawJS.new('ary')}
+        if(hash[:with_row])
+          args[:ajax_args][:data][:row_data] = RawJS.new("jQuery(#{convert_dom_id(dom_id)}).jqGrid('getRowData')")
+        end
+        function << confirm_if_required(confirm, "jQuery.ajax(#{format_type_to_js(args[:url])}.replace(#{format_type_to_js(args[:id_replacement])}, ary[0])#{args[:args_replacements]}, #{format_type_to_js(args[:ajax_args])}); }")
+      else
+        randomizer = rand(99999)
+        function << "parts = ary.map(
+          function(item){
+            return '<input type=\"hidden\" name=\"#{item_id.to_s.pluralize}[]\" value=\"'+item+'\"/>';
+          });
+          #{csrf_token_discovery(args[:method])}
+          var target_url = #{format_type_to_js(args[:url])}.replace(#{format_type_to_js(args[:id_replacement])}, ary[0])#{args[:args_replacements]};
+          jQuery('body').append('<form id=\"jqgrid_redirector_#{randomizer}\" action=\"'+ target_url +'\" method=\"#{args[:method]}\">' + parts + csrf_token + '</form>');
+          #{confirm_if_required(confirm, "jQuery(#{format_type_to_js(format_id("jqgrid_redirector_#{randomizer}"))}).submit();")}
+        }"
+      end
+    end
+
+    # hash:: Argument hash
+    # Builds a default callback based on argument hash. No interaction with
+    # grid is provided via this method
+    def build_default_callback(hash)
+      args = extract_callback_variables(hash)
+      confirm = args.delete(:confirm)
+      if(hash[:remote])
+        "function(){ #{confirm_if_required(confirm, "jQuery.ajax(#{format_type_to_js(args[:url])}#{args[:args_replacements]}, #{format_type_to_js(args[:ajax_args])});")} }"
+      else
+        randomizer = rand(99999)
+        output = " function(){ 
+            #{csrf_token_discovery(args[:method])}
+            jQuery('body').append('<form id=\"jqgrid_redirector_#{randomizer}\" action=\"#{args[:url]}#{args[:args_replacements]}\" method=\"#{args[:method]}\">' + csrf_token + '</form>');"
+        if(hash[:ajax_args] && hash[:ajax_args][:data])
+          output << "var args = #{format_type_to_js(hash[:ajax_args][:data])};
+            Object.keys(args).each(function(key){
+              jQuery('#{format_id("jqgrid_redirector_#{randomizer}")}').append(jQuery('<input/>')
+                .attr('type', 'hidden')
+                .attr('name', key)
+                .val(args[key])
+              );
+            });"
+        end
+        output << "#{confirm_if_required(confirm, "jQuery(#{format_type_to_js(format_id("jqgrid_redirector_#{randomizer}"))}).submit();")}
+          }"
+      end
+    end
+
+    # key:: ondbl_click_row/on_select_row
+    # Sets up click event functions based on hash values
+    def map_click(key, options)
+      if(options[key].is_a?(Hash))
+        options[key][:build_callback] = :item
+        options[key] = hash_to_callback(options[key])
+      end
+    end
+
+    # url_hash:: hash for url building
+    # Creates a toolbar button for the grid
+    # TODO: Put confirm in here
+    def build_toolbar_button(url_hash)
+      url_hash[:empty_selection] ||= url_hash[:single]
+      url_hash[:build_callback] ||= :selection unless url_hash[:empty_selection]
+      classes = ['grid_toolbar_item', 'button', 'ui-state-default', 'ui-corner-all']
+      s = <<-EOS
+jQuery('<div class="#{(classes + Array(url_hash[:class])).compact.join(' ')}" />')
+  .text('#{escape_javascript(url_hash[:name])}')
+    .button()
+      .click(
+        #{hash_to_callback(url_hash)}
+      ).appendTo('#t_' + #{format_type_to_js(@table_id)});
+EOS
+    end
+
+    # options_hash:: Hash of options
+    # Inserts callbacks in any applicable values
+    def scrub_options_hash(options_hash)
+      options_hash.each do |key,value|
+        options_hash[key] = hash_to_callback(value)
+      end
+      options_hash
+    end
+
+    # confirm:: Confirmation string
+    # contents:: JS contents for if block
+    # Wraps contents within if block using confirm() as conditional
+    def confirm_if_required(confirm, contents)
+      string = ''
+      if(confirm)
+        string << "if(confirm(#{format_type_to_js(confirm)})){"
+        string << contents
+        string << "}"
+      else
+        string << contents
+      end
+      string
+    end
+
+    def csrf_token_discovery(method)
+      output = "var csrf_token = '';"
+      if(method.to_s.downcase == 'get')
+        output
+      else
+        output << "if(jQuery('meta[name=\"csrf-param\"]').size() > 0){
+          csrf_token = '<input type=\"hidden\" name=\"'+jQuery('meta[name=\"csrf-param\"]').attr('content')+'\" value=\"'+jQuery('meta[name=\"csrf-token\"]').attr('content')+'\" />';
+        }"
+      end
+    end
+  end
+end