krjs 0.5.5

data/CHANGELOG

@@ -0,0 +1,7 @@
+0.5.5 - Feb 16, 2010
+  * Pushed to gemcutter
+  * Fixed tests so they all pass with Rails 2.3.5
+
+0.5.2 - Sep 08, 2008
+  * Initial release
+  * Gem'ified plugin

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006 Chew Choon Keat
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,76 @@
+= KRJS - Keat's RJS
+
+RJS is a great Ruby DSL to write javascript. However, its so tempting to write 
+RJS directly in the views, and soon the views would contain substantial controller knowledge (e.g. link_to_remote, link_to, etc)
+
+KRJS attempts to solve that problem by allowing dynamic inclusion of AJAX calls on HTML elements. When a controller defines a method (based on naming convention) that handles a client-side event, the rendering engine will do the wiring automatically - when the event happens, an AJAX call will be made to the controller's method which would ideally reply with RJS and update portions of the document.
+
+KRJS could potentially use behavior/selector style javascript instead of modifying elements itself - See http://www.lukeredpath.co.uk/index.php/2006/06/06/introducing-unobtrusive-javascript-for-rails and http://www.vivabit.com/bollocks/2006/02/09/rails-is-the-devil-in-your-client-side-shoulder.
+
+== Examples
+
+To see it in action, create a blank controller and a index.rhtml file:
+./script/generate controller Sample index
+
+In your view (app/views/sample/index.rhtml) write:
+  <%= form_tag({:action => 'submit'}, {:id => 'form'}) %>
+    <%= text_field 'account', 'login', :id => 'account-new-login' %><br />
+    <%= submit_tag 'Login' %>
+  <%= end_form_tag %>
+
+In your controller (app/controllers/sample_controller.rb), write:
+class SampleController < ApplicationController
+  def on_form_submit
+    render :update do |page|
+      page.insert_html :after, params[:dom_id], CGI.escapeHTML(params.inspect)
+    end
+  end
+end
+
+Go to your browser, load the page and click on the submit button. The form 
+should be submitted via ajax (not a fullpage refresh) and rjs code should
+update the page, right after the form (submit button)
+
+You can also try adding this method to the controller:
+  def on_account_login_blur
+    render :update do |page|
+      page.insert_html :after, params[:dom_id], CGI.escapeHTML(params.inspect)
+    end
+  end
+
+View the page again, type in something in the textfield, press the TAB key (to lose focus on the input field). An AJAX call should be made to your controller, and the respective RJS will update the page.
+
+== Explanation
+
+Controller#on_XX_YY means the controller receives ajax requests when event "onYY" of element XX occurs. e.g. if YY is "focus", then the ajax request is sent during "onfocus" even of XX field.
+Controller#on_XX_YY_ZZ means the controller receives ajax requests when field XX is modified - changes are polled every ZZ seconds instead of waiting for event to occur.
+Note: if YY is 'form' or 'submit', XX is considered as a DOM ID for a form instead of a field. This impacts the :with parameter. i.e. for a field, the value is submitted; for a form, the whole form is submitted
+
+== Installation
+
+Go to your RAILS_ROOT directory and execute:
+./script/plugin install http://choonkeat.svnrepository.com/svn/rails-plugins/krjs
+
+== Testing
+
+To test, go to your RAILS_ROOT directory and execute (1 line):
+PLUGIN=krjs rake test:plugins
+
+To be sure you test only KRJS, do it on a clean RAILS directory:
+$ rails test_directory
+$ cd test_directory
+$ script/plugin install \
+    http://choonkeat.svnrepository.com/svn/rails-plugins/krjs
+$ PLUGIN=krjs rake test:plugins
+
+== License
+
+KRJS is released under the MIT license.
+
+== Author
+
+Chew Choon Keat <choonkeat at gmail>
+http://blog.yanime.org/
+
+12 June 2006
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Test the krjs plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/init.rb

@@ -0,0 +1 @@
+require 'krjs'

data/lib/krjs.rb

@@ -0,0 +1,165 @@
+# KRJS (keat's rails java script)
+#
+# MIT license
+
+module Krjs
+  # brought over from tag_helper (exist after 2.0.1)
+  BOOLEAN_ATTRIBUTES = Set.new(%w(disabled readonly multiple))
+
+  def self.included(base)
+    base.class_eval do
+      
+      # just a public copy of the original tag options
+      # we need to overwrite this because InstanceTag and TagHelper
+      # are already bound to its private version.
+      # without this the alias_method_chain seems not to work well
+      def tag_options(options, escape = true)
+        unless options.blank?
+          attrs = []
+          if escape
+            options.each do |key, value|
+              next unless value
+              key = key.to_s
+              value = ::Krjs::BOOLEAN_ATTRIBUTES.include?(key) ? key : escape_once(value)
+              attrs << %(#{key}="#{value}")
+            end
+          else
+            attrs = options.map { |key, value| %(#{key}="#{value}") }
+          end
+          " #{attrs.sort * ' '}" unless attrs.empty?
+        end
+      end
+
+      # adds an observer to the original tag method if needed
+      def tag_with_observer(*attrs) #name, options = nil, open = false
+        appended = observer(attrs[1])
+        return tag_without_observer(*attrs) <<  appended.to_s
+      end
+
+      # adds an observer to the original content_tag method if needed
+      def content_tag_with_observer(name, content, options = {})
+        appended = observer(options)
+        return content_tag_without_observer(name, content, options) + appended.to_s
+      end
+
+      # adds a remote function to the options if needed
+      def tag_options_with_remote_function(options, escape = true)
+        viewer, method_name, event_attr = viewer_method_eventattr(options) #unless options.include?
+        if method_name && event_attr && options[event_attr].nil? 
+          options[event_attr] = remote_function(
+            :url => HashWithIndifferentAccess.new(options).merge({
+              :action => method_name, 
+              :dom_id => options['id'],
+              :dom_index => split_dom_id(options['id'])[1],
+            }), 
+            :with => (event_attr =~ /submit/ || method_name =~ /form/ ? 
+                      '(window.Form ? Form.serialize(this) : jQuery(this).serialize())' : "'dom_value=' + encodeURIComponent(this.value)")
+          ) + "; return false;" 
+        end
+        return tag_options_without_remote_function(options, escape = true)
+      end
+      
+      # chain the new methods with the old ones
+
+      # tag => tag_with_observer
+      # original tag => tag_without_observer
+      # alias_method_chain :tag, :observer
+
+      # content_tag => content_tag_with_observer
+      # original content_tag => content_tag_without_observer
+      alias_method_chain :content_tag, :observer
+
+      # tag_options => tag_options_with_remote_function
+      # original tag_options => tag_option_without_remote_function
+      alias_method_chain :tag_options, :remote_function
+
+      protected
+
+      # creates the javascript needed to observe a form/field
+      # if necessary, otherwise returns nil
+      def observer(options)
+        viewer, method_name, event_attr = viewer_method_eventattr(options)
+        appended = nil
+        if event_attr =~ /^on(\w+)_(\d+)$/
+          on_evt = $1
+          freq = $2
+          observe_options = HashWithIndifferentAccess.new({
+            :url => HashWithIndifferentAccess.new(options).merge({
+              :action => method_name, 
+              :dom_id => options['id'],
+              :dom_index => split_dom_id(options['id'])[1],
+            }), 
+            :with => "'dom_value=' + Form.serialize($('#{options['id']}'))",
+            :frequency => freq.to_i,
+          })
+          if on_evt =~ /(form|submit)/
+            appended = observe_form(options['id'], observe_options)
+          else
+            appended = observe_field(options['id'], observe_options.merge({
+                :with => "'dom_value=' + encodeURIComponent($('#{options['id']}').value)",
+                :on => on_evt,
+                })
+            )
+          end
+        end
+        appended
+      end
+            
+      # there might be a better splitting policy yet?
+      def split_dom_id(dom_id)
+        dom_id = dom_id.to_s.tr('[]', '')
+        dom_id.split(/-/) # based on convention of dashed_dom_id plugin
+      end
+    
+      # given a dom_id, retrieve the defined controller method (if any)
+      # e.g. on_student_submit, on_student_name_change, on_student_grade_focus
+      # if the controller has no methods of such naming conventions, we'll look
+      # to see if there are view templates of such filenames
+      def controller_method(ctrler, dom_id)
+        return nil if dom_id.nil?
+        array = split_dom_id(dom_id)
+        method_match = "on_#{Regexp.escape(array.first)}_"
+        method_match += "(#{Regexp.escape(array[2])}|field|submit)_" if not array[2].nil?
+        regexp = Regexp.new("^#{method_match}(.+)$")
+        ret = ctrler.methods.find{|x| x =~ regexp }
+
+        if ret.nil? && self.respond_to?(:base_path)
+          view_path = File.join(self.base_path, ctrler.controller_name) unless [self.base_path, ctrler.controller_name].include?(nil)
+          Dir.open(view_path) do |dir|
+            ret = dir.find{|x| x =~ regexp }.to_s.gsub(/\.[^\.]+$/, '')
+          end unless view_path.blank? || !(File.exist? view_path)
+        end
+        ret
+      end
+
+      # convenience method to obtain all 3 information
+      def viewer_method_eventattr(options)
+        viewer = self.respond_to?(:controller) ? self : @template_object
+        return [] unless viewer
+        method_name ||= controller_method(viewer.controller, options['id'])
+        event_attr ||= "on#{$1}" if method_name =~ /_([^_]+(|_\d+))$/
+        [viewer, method_name, event_attr]
+      end
+    end
+  end
+end
+
+module ActionView
+  module Helpers
+    module TagHelper
+      include Krjs
+    end
+    class InstanceTag
+      def method_missing(method, *args)
+        if @template_object && @template_object.respond_to?(method)
+          @template_object.send method, *args
+        else
+          super
+        end
+      end
+      include JavaScriptHelper
+      include PrototypeHelper
+      include Krjs
+    end
+  end
+end

data/lib/krjs_with_debug_info.rb

@@ -0,0 +1,242 @@
+# KRJS (keat's rails java script)
+#
+# MIT license
+
+$indent = 0
+def log message
+  puts ' ' * $indent << message
+end
+
+def inc
+  $indent = $indent + 1
+end
+
+def dec
+  $indent = $indent - 1
+end
+
+#module ActionView
+#  module Helpers
+#class InstanceTag
+#  include JavascriptHelper
+#
+#  # reader method used by TagHelper below..
+#  def template_object
+#    @template_object
+#  end
+##
+#  # required by JavascriptHelper
+#  def url_for(options)
+#    template_object.url_for(options)
+#  end
+#end
+
+#[TagHelper].each do |klass|
+#  klass.class_eval do
+#    include PrototypeHelper # this isn't so good?
+
+module Krjs
+  def self.included(base)
+    base.class_eval do
+      def tag_options(options)
+        cleaned_options = options.reject { |key, value| value.nil? }
+        unless cleaned_options.empty?
+          " " + cleaned_options.symbolize_keys.map { |key, value|
+            %(#{key}="#{html_escape(value.to_s)}")
+          }.sort.join(" ")
+        end
+      end
+
+      # adds observer to the original tag method
+      def tag_with_observer(*attrs) #name, options = nil, open = false
+        #debugger
+        puts
+        log '#tag_with_observer ' << attrs.inspect
+        inc
+        appended = observer(attrs[1])
+        res = tag_without_observer(*attrs) <<  appended.to_s
+        dec
+        log '#end_tag_with_observer'
+        return res
+      end
+
+      # adds observer to the original content_tag method
+      def content_tag_with_observer(name, content, options = {})
+        log '#content_tag_with_observer'
+        inc
+        appended = observer(options)
+        res = content_tag_without_observer(name, content, options) + appended.to_s
+        dec
+        log '#end_content_tag_with_observer'
+        return res
+      end
+
+      # adds a remote function to the options if needed
+      def tag_options_with_remote_function(options)
+        #debugger
+        log '#tag_options_with_remotefunction' << options.inspect
+        inc
+        viewer, method_name, event_attr = viewer_method_eventattr(options) #unless options.include?
+        if method_name && event_attr && options[event_attr].nil?
+          # viewer.controller.logger.debug "options before: #{options.inspect}"
+          options[event_attr] = remote_function(
+          :url => HashWithIndifferentAccess.new(options).merge({
+          :action => method_name,
+          :dom_id => options['id'],
+          :dom_index => split_dom_id(options['id'])[1],
+          }),
+          :with => (event_attr =~ /submit/ || method_name =~ /form/ ?
+          'Form.serialize(this)' : "'dom_value=' + encodeURIComponent(this.value)")
+          ) + "; return false;"
+          # viewer.controller.logger.debug "options after: #{options.inspect}"
+          # return false is important to neuter the browser event
+        end
+        result = tag_options_without_remote_function(options)
+        dec
+        log '#end_tag_options_with_remotefunction'
+
+        return result
+      end
+
+      # just a copy  
+      def tag_options(options)
+         cleaned_options = convert_booleans(options.stringify_keys.reject {|key, value| value.nil?})
+         ' ' + cleaned_options.map {|key, value| %(#{key}="#{escape_once(value)}")}.sort * ' ' unless cleaned_options.empty?
+      end
+
+      # chain the new methods with the old ones
+
+      # tag => tag_with_observer
+      # original tag => tag_without_observer
+      alias_method_chain :tag, :observer
+
+      # content_tag => content_tag_with_observer
+      # original content_tag => content_tag_without_observer
+      alias_method_chain :content_tag, :observer
+
+
+      # tag_options => tag_options_with_remote_function
+      # original tag_options => tag_option_without_remote_function
+      alias_method_chain :tag_options, :remote_function
+
+      protected
+
+      # creates the javascript needed to observe a form/field
+      # if necessary, otherwise returns nil
+      def observer(options)
+        log '#observer'
+        inc
+        viewer, method_name, event_attr = viewer_method_eventattr(options)
+        appended = nil
+        if event_attr =~ /^on(\w+)_(\d+)$/
+          on_evt = $1
+          freq = $2
+          observe_options = HashWithIndifferentAccess.new({
+          :url => HashWithIndifferentAccess.new(options).merge({
+          :action => method_name,
+          :dom_id => options['id'],
+          :dom_index => split_dom_id(options['id'])[1],
+          }),
+          :with => "'dom_value=' + Form.serialize($('#{options['id']}'))",
+          :frequency => freq.to_i,
+          })
+          if on_evt =~ /(form|submit)/
+            appended = observe_form(options['id'], observe_options)
+          else
+            appended = observe_field(options['id'], observe_options.merge({
+            :with => "'dom_value=' + encodeURIComponent($('#{options['id']}').value)",
+            :on => on_evt,
+            })
+            )
+          end
+        end
+        dec
+        log '#end_observer'
+        appended
+      end
+
+      # there might be a better splitting policy yet?
+      def split_dom_id(dom_id)
+        dom_id = dom_id.tr('[]', '')
+        dom_id.to_s.split(/-/) # based on convention of dashed_dom_id plugin
+      end
+
+      # given a dom_id, retrieve the defined controller method (if any)
+      # e.g. on_student_submit, on_student_name_change, on_student_grade_focus
+      # if the controller has no methods of such naming conventions, we'll look
+      # to see if there are view templates of such filenames
+      def controller_method(ctrler, dom_id)
+        log '#controller_method'
+        inc
+        if dom_id.nil?
+          dec
+          log '#end_controoller_method'
+          return nil
+        end
+        array = split_dom_id(dom_id)
+        method_match = "on_#{Regexp.escape(array.first)}_"
+        method_match += "(#{Regexp.escape(array[2])}|field|submit)_" if not array[2].nil?
+        regexp = Regexp.new("^#{method_match}(.+)$")
+        ret = ctrler.methods.find{|x| x =~ regexp }
+        # ctrler.logger.debug "match '#{method_match}' finds '#{ret}'"
+        if ret.nil? && self.respond_to?(:base_path)
+          view_path = File.join(self.base_path, ctrler.controller_name)
+          # ctrler.logger.debug "looking to match within #{view_path}"
+          Dir.open(view_path) do |dir|
+            ret = dir.find{|x| x =~ regexp }.to_s.gsub(/\.[^\.]+$/, '')
+          end unless not File.exist? view_path
+        end
+        dec
+        log '#end_controoller_method'
+        ret
+      end
+
+      # convenience method to obtain all 3 information
+      def viewer_method_eventattr(options)
+        log '#viewer_method_eventattr'
+        inc
+        #viewer = nil
+        viewer = self.respond_to?(:controller) ? self : self.template_object
+
+        #controller = eval("controller")
+        #controller ||= eval("template_object.controller")
+        method_name ||= controller_method(viewer.controller, options['id'])
+        # viewer.controller.logger.debug "using method_name #{method_name.inspect}" if method_name
+        event_attr ||= "on#{$1}" if method_name =~ /_([^_]+(|_\d+))$/
+        # viewer.controller.logger.debug "using event_attr #{event_attr.inspect}" if event_attr
+        #puts '#end viewer_method_eventattr'
+        dec
+        log "#end_viewer_method_eventattr #{method_name} #{event_attr}"
+        [viewer, method_name, event_attr]
+      end
+
+    end
+  end
+end
+#    end
+#  end
+#end
+#
+#
+module ActionView
+  module Helpers
+    module TagHelper
+      public :tag_options
+      include Krjs
+    end
+    class InstanceTag
+      def template_object; @template_object; end
+      def url_for(options); template_object.url_for(options); end
+      include JavaScriptHelper
+      include PrototypeHelper
+      public :tag_options      
+      include Krjs
+    end
+  end
+end
+
+#module ActionView
+#  class Base
+#    include Krjs
+#  end
+#end

data/test/krjs_test.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FakeView < ActionView::Base;end
+
+class SampleController < ActionController::Base
+  def index;
+  end
+
+  def alternate_index;
+    render :action => 'index';
+  end
+
+  def on_test_krjs_form_change; # whole form will be submitted here;
+  end
+
+  def on_form_submit
+    render :update do |page|
+      page.insert_html :after, params[:dom_id], CGI.escapeHTML(params.inspect)
+    end
+  end
+
+  def on_account_login_blur
+    render :update do |page|
+      page.insert_html :after, params[:dom_id], CGI.escapeHTML(params.inspect)
+    end
+  end
+
+  def on_account_password_change_3
+    render :update do |page|
+      page.insert_html :after, params[:dom_id], CGI.escapeHTML(params.inspect)
+    end
+  end
+
+  def on_account_comments_change
+    render :update do |page|
+      page.insert_html :after, params[:dom_id], CGI.escapeHTML(params.inspect)
+    end
+  end
+
+  def on_account_country_change_9
+    render :update do |page|
+      page.insert_html :after, params[:dom_id], CGI.escapeHTML(params.inspect)
+    end
+  end
+end
+
+SampleController.view_paths=(File.join(File.dirname(__FILE__), 'views'))
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+end
+
+class SampleControllerTest < ActionController::TestCase
+
+  def setup
+    @fakeview = FakeView.new  # a view to test the TagHelper methods have been chained
+  end
+
+  def test_presence_of_instance_methods
+    # removed tag_without_observer since Choon commented # alias_method_chain :tag, :observer
+    %w{tag_options tag_options_with_remote_function tag_options_without_remote_function tag tag_with_observer
+         content_tag content_tag_with_observer content_tag_without_observer}.each do |instance_method|
+      assert_respond_to @fakeview, instance_method
+    end
+  end
+
+  def test_basic
+    get :index
+    assert_not_ajaxified 'form', 'change', 'form submit'
+    assert_ajaxified 'form', 'submit', 'form submit'
+
+    assert_not_ajaxified 'account-new-login', 'focus', 'login onblur'
+    assert_ajaxified 'account-new-login', 'blur', 'login onblur'
+
+    assert_not_ajaxified 'account-new-password', 'change', 'password onchange'
+    # assert_ajaxified 'account-new-password', 'observe', 'password onchange'
+
+    assert_not_ajaxified 'remember', 'blur', 'remember onblur'
+    
+    assert_not_ajaxified 'account_comments', 'blur', 'account_comments onblur'
+    assert_ajaxified 'account_comments', 'change', 'account_comments onchange'    
+
+    assert_not_ajaxified 'account_country', 'change', 'account_country onblur'
+    assert_ajaxified 'account_country', 'observe', 'account_country observe'    
+
+    # external .rjs file - NOTE: I don't know if external rjs ever worked, but it doesn't work now
+    # assert_ajaxified 'remember', 'change', 'remember onchange'
+  end
+
+  def test_form
+    get :form_test
+    assert @response.body =~ /Form.serialize/, "Ajaxified form must submit as whole, not merely dom_value"
+    assert_ajaxified 'test_krjs_form', 'change', 'on_test_krjs_form_change'
+  end
+
+  def test_optional_action
+
+  end
+
+  def test_optional_callback
+
+  end
+
+protected
+
+  def assert_ajaxified(dom_id, event, assert_comments=nil)
+    ttag, observer = rendered_html(dom_id, event)
+    case event
+    when 'observe'
+      assert(!observer.blank?, "#{assert_comments}\n#{ttag} #{observer}\n\n#{@response.body}")
+    else
+      assert((ttag =~ / on#{event}\=/), "#{assert_comments}\n#{ttag} #{observer}\n\n#{@response.body}")
+    end
+  end
+
+  def assert_not_ajaxified(dom_id, event, assert_comments=nil)
+    tag, observer = rendered_html(dom_id, event)
+    case event
+    when 'observe'
+      assert(observer.blank?, "#{assert_comments}\n#{tag} #{observer}\n\n#{@response.body}")
+    else
+      assert_nil((tag =~ / on#{event}\=/), "#{assert_comments}\n#{tag} #{observer}\n\n#{@response.body}")
+    end
+  end
+
+  # returns an array,
+  # first element is the tag of the dom_id: e.g. "<form id='thisform'.... >" if dom_id is "thisform"
+  # second element (nillable) is the '<script ... </script>' appended to the tag by rjs if its an observed field
+  def rendered_html(dom_id, event)
+    if @response.body =~ /(\<([^\>]+) id="#{Regexp.escape(dom_id.to_s)}".*?\>(.+\2>\s*<script))/m
+        # matches <select>... </select><script
+        tag = $2
+        return tag, $1 if $3 =~ /\/#{tag}>(.+)/
+    end
+    assert @response.body =~ /(\<[^\>]+ id="#{Regexp.escape(dom_id.to_s)}".*?\>(<script |))/m, "Cannot find #{Regexp.escape(dom_id.to_s)} in #{$1}\n\n#{@response.body}"
+    return $1, $2
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+RAILS_ENV = 'test'
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+require 'test/unit'
+require 'krjs'

data/test/views/layouts/sample.rhtml

@@ -0,0 +1,10 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+   <html>
+   <head>
+     <%= javascript_include_tag :defaults %>
+   </head>
+   <body>
+   <%= yield %>
+   </body>
+   </html> 

data/test/views/sample/form_test.rhtml

@@ -0,0 +1,14 @@
+<html><head>
+  <%= javascript_include_tag :defaults %>
+</head><body>
+
+<% form_tag({:action => 'submit'}, {:id => 'test_krjs_form'}) do %>
+<label for="object_value">Value : </label>
+<%= text_field 'object', 'value' %><br/>
+<label for="state">State : </label>
+<%= text_field_tag 'state'%><br/>
+
+<%= submit_tag "Save" %>
+<% end %>
+
+</body></html>

data/test/views/sample/index.rhtml

@@ -0,0 +1,15 @@
+<% form_tag({:action => 'submit'}, {:id => 'form'}) do %>
+  Login: <%= text_field 'account', 'login', :id => 'account-new-login' %><br />
+  Password: <%= password_field_tag 'account[password]', nil,
+        :id => 'account-new-password' %><br />
+  <%= check_box_tag 'remember' %> Remember login?<br />
+
+  Comments?
+  <%= text_area 'account', 'comments' %><br />
+
+  Country:
+  <%= select 'account', 'country', ['US', 'Canada', 'Others'] %><br />
+
+  <p />
+  <%= submit_tag 'Login' %>
+<% end %>

data/test/views/sample/on_remember_change.rjs

@@ -0,0 +1,2 @@
+# Note, test for this is commented because it doesn't appear external rjs works
+page.insert_html :after, 'form', CGI.escapeHTML(params.inspect)

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: krjs
+version: !ruby/object:Gem::Version 
+  version: 0.5.5
+platform: ruby
+authors: 
+- Choon Keat
+- Wes Hays
+- John Dell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-16 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: RJS is a great Ruby DSL to write javascript. However, it's so tempting to write RJS directly in the views, and soon the views contain substantial controller knowledge (e.g. link_to_remote, link_to, etc)  KRJS attempts to solve that problem by allowing dynamic inclusion of AJAX calls on HTML elements. When a controller defines a method (based on naming convention) that handles a client-side event, the rendering engine will do the wiring  automatically - when the event happens, an AJAX call will be made to the controller's method which would ideally reply  with RJS and update portions of the document.
+email: gems@gbdev.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README
+- Rakefile
+- init.rb
+- lib/krjs.rb
+- lib/krjs_with_debug_info.rb
+- test/krjs_test.rb
+- test/test_helper.rb
+- test/views/layouts/sample.rhtml
+- test/views/sample/form_test.rhtml
+- test/views/sample/index.rhtml
+- test/views/sample/on_remember_change.rjs
+has_rdoc: true
+homepage: http://github.com/gbdev/krjs
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Keat's RJS - using RJS without messing with your Views
+test_files: 
+- test/krjs_test.rb
+- test/test_helper.rb
+- test/views/layouts/sample.rhtml
+- test/views/sample/form_test.rhtml
+- test/views/sample/index.rhtml
+- test/views/sample/on_remember_change.rjs