motr 0.0.3 → 0.0.4

data/Gemfile

@@ -5,9 +5,18 @@ gem "capybara", ">= 0.4.0"
 gem "sqlite3-ruby"
 gem "rspec-rails"
 gem "mocha","0.9.12"
+gem "minitest"
+
+group :mongoid do
+  gem 'mongo', '~> 1.3'
+  gem 'bson_ext', '~> 1.3'
+  gem 'mongoid', '~> 2.0'
+end
 
 group :test do
+  gem "colored"
+  gem 'shoulda-context'
   gem 'fabrication', '0.9.5'
   gem 'ffaker', '1.5.0'
-  gem 'spork', '~> 0.9.0.rc'
+  gem 'spork', '~> 0.9.0.rc', :require => false
 end

data/README.rdoc

@@ -2,8 +2,11 @@
 
 {Official Documentation}[http://rubydoc.info/github/kurbmedia/motr/master/frames]
 
-Motr is a basic Rails engine which adds additional functionality to your applications. The {core Motr}[http://github.com/kurbmedia/motr] engine 
-provides a number of helpers and functionality geared towards bringing the ease of Rails back-end development, to the front-end.
+Motr is a basic Rails engine which adds additional functionality to your applications, and creates the ability to "extend" models 
+easily to support routine functionality. The {core Motr}[http://github.com/kurbmedia/motr] engine 
+provides a number of helpers and functionality geared towards bringing the ease of Rails back-end development, to the front-end. It
+also implements a {Devise}[https://github.com/plataformatec/devise] inspired "hook" system to support easily adding data functionality to 
+models in a similar manner to how Devise adds session management functionality.
 
 Rails view helpers and form builders are convenient an easy to use, however some aren't very design/html friendly (whose idea was it to 
 wrap fields with errors in a div?). The goal is to keep html valid and sensible where possible, and make things like javascript integration 
@@ -18,6 +21,10 @@ Motr is maintained and funded by {kurb media}[http://kurbmedia.com/], and was de
 opinionated in how it works. However, additions / enhancements / alternative methods are more than welcome and encouraged. We also welcome 
 feature requests, especially from designers/front-end developers who spend a lot of time working along-side Rails developers.
 
+== Credits
+
+Thanks to José Valim and {Devise}[https://github.com/plataformatec/devise] which inspired the model hook functionality.
+
 == License
 
 Motr is Copyright © 2010-2011 kurb media, llc.

data/Rakefile

@@ -13,11 +13,19 @@ require 'rake/rdoctask'
 
 require 'rspec/core'
 require 'rspec/core/rake_task'
+require 'rake/testtask'
 
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
 
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title    = 'motr'

data/app/helpers/motr_helper.rb

@@ -1,8 +1,2 @@
 module MotrHelper #:nodoc:
-
-  include Motr::Helpers::LayoutHelpers
-  include Motr::Helpers::Navigation
-  include Motr::Helpers::Elements
-  include Motr::Forms::Helpers  
-  
 end

data/lib/motr.rb

@@ -3,35 +3,83 @@ require 'active_support/dependencies'
 require 'set'
 
 require 'motr/forms'
+require 'motr/model'
 
 module Motr
-  
-  module Controller
-    autoload :Responder,    'motr/controller/responder'
-    autoload :ScriptEvents, 'motr/controller/script_events'
+
+  module Controller #:nodoc:
+    autoload :Helpers,    'motr/controller/helpers'
+    autoload :Responder,  'motr/controller/responder'
   end
-  
-  module Helpers
+
+  module Helpers #:nodoc:
     autoload :LayoutHelpers, 'motr/helpers/layout_helpers'
     autoload :Navigation,    'motr/helpers/navigation'
     autoload :Elements,      'motr/helpers/elements'
   end
   
-  module Errors
+  module Errors #:nodoc:
     autoload :MotrError,      'motr/errors/motr_error'
     autoload :InvalidOptions, 'motr/errors/invalid_options'
+    autoload :ModuleMissing,  'motr/errors/module_missing'
+  end
+  
+  # Store configurations for included models
+  ALL         = []
+  CONFIGS     = {}
+  
+  ##
+  # 
+  # Enable adding models to the core Motr library. These modules
+  # can then be included/initialized using the +motr+ method.
+  # 
+  # @param [Symbol] module_name The name of the module to be added (underscored)
+  # @param [Hash] config Default configuration options for the module
+  # 
+  # @option config [String, Boolean] :autoload The path to autoload the module from (optional)
+  # 
+  # All other configuration options are considered default options for that particular module.
+  # 
+  # 
+  def self.add_module(module_name, config = {})
+    
+    # Store a reference to any module loaded
+    ALL << module_name
+    config.assert_valid_keys(:autoload)
+     
+    const_name = ActiveSupport::Inflector.camelize(module_name.to_s)
+
+    # Setup autoloading for this module if necessary
+    if autoload_path = config.delete(:autoload)
+      path = (autoload_path == true ? "motr/model/#{module_name.to_s}" : autoload_path)
+      Motr::Model.send(:autoload, const_name, path)
+    end
+    
+    # Setup placeholder for configuration
+    Motr::CONFIGS[module_name] ||= {}
+        
+    # Setup configuration method for module.
+    # 
+    self.class_eval <<-METHOD, __FILE__, __LINE__ + 1      
+      def self.#{module_name.to_s}(options = {})
+        raise Motr::Errors::InvalidOptions.new('Configuration for #{module_name} must be a hash.') unless options.is_a?(Hash)
+        Motr::CONFIGS[:#{module_name.to_s}].merge!(options)
+      end      
+    METHOD
+    
+    # Apply any defaults
+    Motr.send(:"#{module_name}", config)
+    
   end
   
   # Support initializer configuration
+  # @private
+  # 
   def self.configure #:nodoc:
     yield self
   end
   
-  # Support configuration of the forms module
-  def self.forms #:nodoc:
-    yield Motr::Forms
-  end
-
 end
 
+require 'motr/defaults'
 require 'motr/rails'

data/lib/motr/controller/helpers.rb

@@ -0,0 +1,83 @@
+require 'action_controller/base'
+
+module Motr
+  module Controller
+   
+    module Helpers
+      extend ActiveSupport::Concern
+      
+      included do
+        after_filter :generate_ajax_headers
+        class_attribute :response_metadata
+        self.response_metadata = {}
+      end
+      
+      ##
+      # Generates additional header information for ajax requests, to allow more flexibility in 
+      # handling responses. It simply creates a X-Response-Meta header in the response which contains 
+      # a json object representing the requested controller and action name, as well as any user defined metadata set with +add_response_meta+
+      # 
+      # @see Motr#Controller#Helpers#add_response_meta
+      # @private
+      # 
+      def generate_ajax_headers  #:nodoc:
+        return true unless response.content_type.to_s.match(/javascript/i)
+        
+        response_params = request.filtered_parameters.dup
+        controller_name = response_params.delete('controller').to_s.underscore
+        action_name     = response_params.delete('action').to_s
+        
+        parsed_meta = self.class.response_metadata
+        parsed_meta = case parsed_meta
+          when Symbol then send(parsed_meta)
+          when Proc   then parsed_meta.call
+          else parsed_meta
+        end
+        
+        meta_info       = {
+          :pathinfo => "#{controller_name}##{action_name}",
+          :meta     => parsed_meta
+        }
+        response.header['X-Response-Meta'] = meta_info.to_json
+        
+      end
+      
+      module ClassMethods #:nodoc:
+        
+        ##
+        # Adds additional "meta" information to AJAX response headers. By default an additional 
+        # X-Response-Meta header is added to ajax requests which describes the current controller/action names. Passing 
+        # additional information to this method adds data to that header.
+        # 
+        # @param [Hash,Proc,Symbol] options Information to be added to the response header. If a hash is used, the data is passed
+        #   directly. If a symbol is used, it is considered an instance method to be called on the controller. If a proc is used 
+        #   it is evaluated when the data is built. NOTE: Procs/methods are called AFTER actions are run. This way action data can be used.
+        # 
+        # @example Add a "post_name" meta
+        # 
+        #   class PostsController < ApplicationController
+        #     add_response_meta { :post_name => 'This post is awesome' }
+        #   end
+        #   * index action run *
+        #   
+        #   'X-Response-Meta' #=> { :pathinfo => 'posts#index', :meta => { :post_name => 'This post is awesome' } }
+        # 
+        # 
+        def add_response_meta(options)
+          self.response_metadata = options
+        end
+        
+        ##
+        # @deprecated Use add_response_meta
+        # 
+        def enable_script_events(opts = {})
+          ActiveSupport::Deprecation.issue_warning("enable_script_events is deprecated. Please use the 'add_response_meta helper'")
+          response_metadata = opts
+        end
+        
+      end
+      
+    end
+    
+  end  
+end

data/lib/motr/controller/responder.rb

@@ -1,20 +1,19 @@
 require 'action_controller/base'
 
 module Motr
-  module Controller
+  module Controller #:nodoc:
     
     ##
     # 
     # A custom responder which extends the default functionality of respond_with to handle
     # more advanced javascript functionality, as well as flash messages.
     # 
-    # Slightly modeled after José Valim's Responders gem (https://github.com/plataformatec/responders)
+    # @see The ActionController::Metal::Responder (https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/metal/responder.rb) for more info
     # 
-    # @see (https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/metal/responder.rb) for more info
-    # 
-    class Responder <  ActionController::Responder
+    class Responder <  ActionController::Responder #:nodoc:
       
-      def initialize(controller, resources, options = {}) #:nodoc:
+      # @private
+      def initialize(controller, resources, options = {})
         super
         flash = (format == :js) ? controller.flash : controller.flash.now
         [:success, :notice, :error].each do |key|
@@ -24,8 +23,9 @@ module Motr
       
       ##
       # Override to_js to set a +X-Flash-Messages+ header to be utilized by an ajax response.
+      # @private
       # 
-      def to_js #:nodoc:
+      def to_js
         flash = controller.flash.now
         controller.response['X-Flash-Messages'] = flash.to_json if [:success, :notice, :error].detect{ |key| flash[key].present? }
         defined?(super) ? super : to_format        

data/lib/motr/defaults.rb

@@ -0,0 +1 @@
+Motr.add_module(:sluggable, :autoload => true)

data/lib/motr/errors/invalid_options.rb

@@ -7,7 +7,7 @@ module Motr #:nodoc
     # 
     # 
     # 
-    class InvalidOptions < MotrError
+    class InvalidOptions < MotrError #:nodoc:
     end
   end
 end

data/lib/motr/errors/module_missing.rb

@@ -0,0 +1,13 @@
+module Motr #:nodoc
+  module Errors #:nodoc
+
+    ##
+    # Raised when trying to load a module that has not been added.
+    # @param (see Motr#Errors#MotrError)
+    # 
+    # 
+    # 
+    class ModuleMissing < MotrError #:nodoc:
+    end
+  end
+end

data/lib/motr/forms.rb

@@ -1,6 +1,6 @@
 module Motr
   
-  module Forms
+  module Forms #:nodoc:
     
     autoload :Base,    'motr/forms/base'
     autoload :Helpers, 'motr/forms/helpers'

data/lib/motr/forms/base.rb

@@ -5,7 +5,7 @@ module Motr
     ##
     # Base class for creating form builders
     # 
-    class Base < ActionView::Helpers::FormBuilder
+    class Base < ActionView::Helpers::FormBuilder #:nodoc:
       
       # Access the template object
       attr_accessor :template
@@ -17,6 +17,7 @@ module Motr
       
             
       # Overrides fields_for to make sure the form builder is set properly
+      # 
       def fields_for(record_or_name_or_array, *args, &block) #:nodoc:
         opts = args.extract_options!
         opts[:builder] ||= Motr::Forms.default_builder
@@ -205,7 +206,7 @@ module Motr
       
       private
       
-      def validator_of_type_exists?(validators, kind, check_options = true) #:nodoc:
+      def validator_of_type_exists?(validators, kind, check_options = true) #:nodoc: @private
         validators.detect do |validator| 
           exists = (validator.kind.to_s == kind.to_s)
           next exists unless (check_options && exists) && validator.options.present?

data/lib/motr/forms/builder.rb

@@ -6,10 +6,10 @@ module Motr
     # Default Motr form builder. Extends the passed input tags to include additional 
     # html attributes, primarily for javascript integration.
     #
-    class Builder < Motr::Forms::Base
+    class Builder < Motr::Forms::Base #:nodoc:
       
       # create overrides for custom rendering
-      [:email_field, :password_field, :text_field, :text_area, :url_field, ].each do |method|      
+      [:email_field, :password_field, :text_field, :text_area, :url_field].each do |method|      
         class_eval <<-FUNC, __FILE__, __LINE__ + 1
           
           alias :_super_#{method} :#{method}
@@ -21,9 +21,10 @@ module Motr
       end
       
       ##
-      # Modified label tag to support adding a 'required' asterisk to the end of the label
+      # Modified label tag to support adding a 'required' asterisk to the end of the label.
+      # Same params as the original implementation
       # 
-      def label(method, text = nil, options = {}, &block)
+      def label(method, text = nil, options = {}, &block) #:nodoc:
         
         options, text = text, nil if text.is_a?(Hash)
         text ||= method.to_s.humanize

data/lib/motr/helpers/navigation.rb

@@ -72,6 +72,7 @@ module Motr
       
       private
       
+      # @private
       def update_link_attrs(path, attrs)
         
         proc          = attrs.delete(:proc)

data/lib/motr/model.rb

@@ -0,0 +1,124 @@
+module Motr
+
+  ##
+  # Provides a interface for extending models and controllers with additional Motr libraries.
+  # To create a new library, sub-class/module Motr::Model or Motr::Controller depending on the 
+  # functionality to include. To 'attach' functionality call motr :module_name 
+  # 
+  # @example Create a "postable" model using Motr::Model::Postable (see the motr-content gem)
+  #   class MyPost
+  #     motr :postable
+  #   end
+  #
+  module Model
+    ##
+    # Stores a list of available options for a model. This way when 
+    # options are passed at load-time, they can be applied to the proper modules.
+    # 
+    # @param [Class, Module] mod The module to configure
+    # @param [Symbol] cfg_name The name of the configuration to modify
+    # @param [Array] *options Argument list of options to create.
+    # 
+    # @example Create configuration options on a module
+    #   module Motr::Model::Sample
+    #     module ClassMethods
+    #       Motr::Model.config(self, :sample, :option1, :option2)
+    #     end
+    #   end
+    #
+    #
+    def self.config(mod, cfg_name, *options)
+      (class << mod; self; end).send(:attr_accessor_with_default, :motr_options, {})
+      mod.motr_options[cfg_name] ||= []
+      
+      options.each do |option|
+        mod.motr_options[cfg_name] << option
+        fullname = [cfg_name, option].map(&:to_s).join("_")
+                
+        mod.class_eval <<-METHOD, __FILE__, __LINE__ + 1
+          def #{fullname}
+            if defined?(@#{fullname})
+              @#{fullname}
+            elsif superclass.respond_to?(:#{fullname})
+              superclass.#{fullname}
+            else
+              Motr::CONFIGS[:#{cfg_name}][:#{option}]
+            end
+          end
+          def #{fullname}=(value)
+            @#{fullname} = value
+          end
+        METHOD
+      end
+    end
+    
+    ##
+    # The motr method enables loading other motr libraries into application modules/classes.
+    # 
+    # @example Create a model include to hook into any model class
+    #   module Motr::Model::Sample
+    #     def instance_method
+    #     end
+    # 
+    #     module ClassMethods
+    #       def class_method
+    #       end
+    #     end
+    #   end
+    # 
+    #   class SomeModel < ActiveRecord::Base
+    #     motr :sample
+    #   end
+    # 
+    # 
+    def motr(*mods)
+      
+      options  = mods.extract_options!
+      modules  = mods.map(&:to_sym).uniq
+
+      motrize_model! do
+        
+        modules.each do |mod|          
+          const_name = mod.to_s.classify
+          raise Motr::Model.load_failure("Motr::Model::#{const_name}") unless Motr::ALL.include?(mod)
+          
+          begin
+            const_incl = Motr::Model.const_get(:"#{const_name}")
+          rescue NameError
+            raise Motr::Errors.ModuleMissing.new("Motr::Model::#{const_name} could not be found. Perhaps try adding the module with the :autoload option.")
+          end
+          
+          if const_incl.const_defined?('ClassMethods')
+            class_incl = const_incl.const_get("ClassMethods")
+            extend class_incl
+          end
+          # # Apply passed options to modules where applicable.
+          # 
+          if class_incl.respond_to?(:motr_options)
+            class_incl.motr_options[mod].each do |option|
+              next unless options.key?(option)
+              send(:"#{mod}_#{option}=", options.delete(option))
+            end
+          end
+          
+          include const_incl
+          
+        end
+      end
+    end
+    
+    # Raise a ModuleMissing error if a module cannot be loaded.
+    # @private
+    # 
+    def self.load_failure(mod) #:nodoc:
+      Motr::Errors::ModuleMissing.new("The module #{mod} wasn't found. Add it with Motr.add_module(#{mod})") and return
+    end
+    
+    # Override motrize_model! to create specific functionality on a model
+    # @private
+    def motrize_model! #:nodoc:
+      yield
+    end
+    
+  end
+end

data/lib/motr/model/sluggable.rb

@@ -0,0 +1,45 @@
+module Motr
+  module Model
+    
+    module Sluggable #:nodoc:
+      extend ActiveSupport::Concern
+      
+      included do
+        callback_opt = (self.sluggable_on || "save")
+        send(:"before_#{callback_opt.to_s}", :make_sluggable_fields)
+      end
+      
+      # @private
+      def make_sluggable_fields #:nodoc:
+        [self.class.sluggable_fields].flatten.each do |atr|
+          orig = self.send(:"#{atr}")
+          self.send(:"#{atr}=", orig.to_slug)
+        end
+      end
+      
+      # @private
+      module ClassMethods #:nodoc:
+        Motr::Model.config(self, :sluggable, :fields, :on)
+      end
+      
+    end
+    
+  end
+end
+
+##
+# Original implementation by Ludo van den Boom's to_slug plugin 
+# @see to_slug (https://github.com/ludo/to_slug)
+#
+module ToSlug #:nodoc:
+  def to_slug
+    value = self.mb_chars.normalize(:kd).gsub(/[^\x00-\x7F]/n, '').to_s
+    value.gsub!(/[']+/, '')
+    value.gsub!(/\W+/, ' ')
+    value.strip!
+    value.downcase!
+    value.gsub!(' ', '-')
+    value
+  end
+end
+String.send(:include, ToSlug)

data/lib/motr/orm/active_record.rb

@@ -0,0 +1,16 @@
+module Motr
+  module Orm
+    
+    module ActiveRecord #:nodoc:
+      extend ActiveSupport::Concern
+      
+      included do        
+        extend Motr::Model
+      end
+      
+    end
+    
+  end
+end
+
+ActiveRecord::Base.send :include, Motr::Orm::ActiveRecord

data/lib/motr/orm/mongoid.rb

@@ -0,0 +1,13 @@
+module Motr
+  module Orm
+    
+    module Mongoid #:nodoc:
+    end
+    
+  end
+end
+
+Mongoid::Document::ClassMethods.class_eval do
+  include Motr::Model
+  include Motr::Orm::Mongoid
+end

data/lib/motr/rails.rb

@@ -6,12 +6,19 @@ module Motr
     require 'active_support/i18n'
     I18n.load_path << File.expand_path('../../config/locales/en.yml', __FILE__)
     
-    initializer :after_initialize do
-      ActionView::Base.send :default_form_builder=, Motr::Forms.default_builder
-      ApplicationController.class_eval do 
+    initializer 'motr.initializer' do
+      ActiveSupport.on_load(:action_view) do
+        include Motr::Helpers::LayoutHelpers
+        include Motr::Helpers::Navigation
+        include Motr::Helpers::Elements
+        include Motr::Forms::Helpers
+        self.send :default_form_builder=, Motr::Forms.default_builder
+      end      
+      ActiveSupport.on_load(:action_controller) do
+        include Motr::Controller::Helpers
         self.responder = Motr::Controller::Responder
       end
-      ActionController::Base.extend Motr::Controller::ScriptEvents
+      
     end
     
   end

data/lib/motr/version.rb

@@ -1,3 +1,3 @@
 module Motr #:nodoc:
-  VERSION = "0.0.3".freeze
+  VERSION = "0.0.4".freeze
 end

metadata

@@ -2,7 +2,7 @@
 name: motr
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Brent Kirby
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-04 00:00:00 -04:00
+date: 2011-05-09 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -123,9 +123,11 @@ files:
 - lib/generator/templates/compass/screen.scss
 - lib/generator/templates/motr.rb
 - lib/generator/templates/post_install
+- lib/motr/controller/helpers.rb
 - lib/motr/controller/responder.rb
-- lib/motr/controller/script_events.rb
+- lib/motr/defaults.rb
 - lib/motr/errors/invalid_options.rb
+- lib/motr/errors/module_missing.rb
 - lib/motr/errors/motr_error.rb
 - lib/motr/forms/base.rb
 - lib/motr/forms/builder.rb
@@ -134,6 +136,10 @@ files:
 - lib/motr/helpers/elements.rb
 - lib/motr/helpers/layout_helpers.rb
 - lib/motr/helpers/navigation.rb
+- lib/motr/model/sluggable.rb
+- lib/motr/model.rb
+- lib/motr/orm/active_record.rb
+- lib/motr/orm/mongoid.rb
 - lib/motr/rails.rb
 - lib/motr/version.rb
 - lib/motr.rb
@@ -156,7 +162,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2716753183944900755
+      hash: 2672633965524668472
       segments: 
       - 0
       version: "0"

data/lib/motr/controller/script_events.rb

@@ -1,77 +0,0 @@
-require 'action_controller/base'
-
-module Motr
-  module Controller
-    
-    ##
-    # Enables triggering javascript events from controllers. This helps with extraction of javascript from 
-    # actual view templates. Since by default Rails' respond_with will render a html template on a js request 
-    # where there is no .js.erb template, we can capture that content and trigger a javascript event with it.
-    # 
-    # @option options [Symbol] :type The type of callback to use (only supports :jquery right now)
-    #
-    # @example 
-    #   In your controller:
-    #     controller SomeResourceController < ApplicationController
-    #       respond_to :html, :js
-    #       enable_script_events :only => :create
-    # 
-    #       def create
-    #         # some create functionality here
-    #         # @some_resource.name = "Test"
-    #         respond_with(@some_resource)
-    #       end
-    # 
-    #     end
-    # 
-    #   With the view "create.html.erb"
-    #   
-    #   <div id="resource"><%= @some_resource.name %></div>
-    # 
-    #   Will return (where the last param is an object notation of any params passed (after filtering))
-    # 
-    #     jQuery.trigger("some_resource:create", "<div id=\"resource\">Test</div>", {});
-    #
-    # 
-    module ScriptEvents
-      
-      def enable_script_events(options = {})  #:nodoc:
-        
-        
-        after_filter(options) do
-          
-          # TODO: Possibly support other js libraries? I mean... does anyone care? I don't
-          #event_type = options.delete(:type) || :jquery
-          event_type   = :jquery
-          callback_str = case event_type.to_s
-            when 'prototype' then "alert('sorry, no prototype love');"
-            else "jQuery.event.trigger('%s:%s', [%s, %s]);"
-          end
-          
-          return true unless response.content_type.to_s.match(/javascript/i)
-          response_params = request.filtered_parameters.dup
-          
-          cname      = response_params.delete('controller').to_s.underscore
-          aname      = response_params.delete('action').to_s
-          escape_map = {
-                  '\\'    => '\\\\',
-                  '</'    => '<\/',
-                  "\r\n"  => '\n',
-                  "\n"    => '\n',
-                  "\r"    => '\n',
-                  '"'     => '\\"',
-                  "'"     => "\\'" }
-          
-          response_params.delete("format")
-          json_params   = response_params.to_json#.gsub(/(\\|<\/|\r\n|[\n\r"'])/) { escape_map[$1] }
-          old_body      = response.body.gsub(/(\\|<\/|\r\n|[\n\r"'])/) { escape_map[$1] }
-          response.body = callback_str % [cname, aname, old_body.inspect, json_params.html_safe]
-          
-        end
-        
-      end
-      
-    end
-    
-  end  
-end