eita-jrails 0.9.0 → 0.9.1

data/lib/action_view/helpers/jquery_ui_helper.rb

@@ -0,0 +1,165 @@
+module ActionView
+  module Helpers
+
+    module JqueryUiHelper
+
+      JQUERY_VAR = ::JRails::JQUERY_VAR
+
+      SCRIPTACULOUS_EFFECTS = {
+        appear: {method: 'fadeIn'},
+        blind_down: {method: 'blind', mode: 'show', options: {direction: 'vertical'}},
+        blind_up: {method: 'blind', mode: 'hide', options: {direction: 'vertical'}},
+        blind_right: {method: 'blind', mode: 'show', options: {direction: 'horizontal'}},
+        blind_left: {method: 'blind', mode: 'hide', options: {direction: 'horizontal'}},
+        bounce_in: {method: 'bounce', mode: 'show', options: {direction: 'up'}},
+        bounce_out: {method: 'bounce', mode: 'hide', options: {direction: 'up'}},
+        drop_in: {method: 'drop', mode: 'show', options: {direction: 'up'}},
+        drop_out: {method: 'drop', mode: 'hide', options: {direction: 'down'}},
+        fade: {method: 'fadeOut'},
+        fold_in: {method: 'fold', mode: 'hide'},
+        fold_out: {method: 'fold', mode: 'show'},
+        grow: {method: 'scale', mode: 'show'},
+        shrink: {method: 'scale', mode: 'hide'},
+        slide_down: {method: 'slide', mode: 'show', options: {direction: 'up'}},
+        slide_up: {method: 'slide', mode: 'hide', options: {direction: 'up'}},
+        slide_right: {method: 'slide', mode: 'show', options: {direction: 'left'}},
+        slide_left: {method: 'slide', mode: 'hide', options: {direction: 'left'}},
+        squish: {method: 'scale', mode: 'hide', options: {origin: "['top','left']"}},
+        switch_on: {method: 'clip', mode: 'show', options: {direction: 'vertical'}},
+        switch_off: {method: 'clip', mode: 'hide', options: {direction: 'vertical'}},
+        toggle_appear: {method: 'fadeToggle'},
+        toggle_slide: {method: 'slide', mode: 'toggle', options: {direction: 'up'}},
+        toggle_blind: {method: 'blind', mode: 'toggle', options: {direction: 'vertical'}},
+      }
+
+      def visual_effect(name, element_id = false, js_options = {})
+        if SCRIPTACULOUS_EFFECTS.has_key? name.to_sym
+          effect = SCRIPTACULOUS_EFFECTS[name.to_sym]
+          name = effect[:method]
+          mode = effect[:mode]
+          js_options = js_options.merge(effect[:options]) if effect[:options]
+        end
+
+        [:color, :direction, :startcolor, :endcolor].each do |option|
+          js_options[option] = "'#{js_options[option]}'" if js_options[option]
+        end
+
+        if js_options.has_key? :duration
+          speed = js_options.delete :duration
+          speed = (speed * 1000).to_i unless speed.nil?
+        else
+          speed = js_options.delete :speed
+        end
+
+        if ['fadeIn','fadeOut','fadeToggle'].include?(name)
+          #	090905 - Jake - changed ' to \" so it passes assert_select_rjs with an id
+          javascript = "#{JQUERY_VAR}(\"#{jquery_id(element_id)}\").#{name}("
+          javascript << "#{speed}" unless speed.nil?
+          javascript << ");"
+        else
+          #	090905 - Jake - changed ' to \" so it passes "assert_select_rjs :effect, ID"
+          javascript = "#{JQUERY_VAR}(\"#{jquery_id(element_id)}\").#{mode || 'effect'}('#{name}'"
+          javascript << ",#{options_for_javascript(js_options)}" unless speed.nil? && js_options.empty?
+          javascript << ",#{speed}" unless speed.nil?
+          javascript << ");"
+        end
+
+      end
+
+      def drop_receiving_element(element_id, options = {})
+        javascript_tag(drop_receiving_element_js(element_id, options).chop!)
+      end
+
+      def draggable_element(element_id, options = {})
+        javascript_tag(draggable_element_js(element_id, options).chop!)
+      end
+
+      def sortable_element(element_id, options = {})
+        javascript_tag(sortable_element_js(element_id, options).chop!)
+      end
+
+      def sortable_element_js(element_id, options = {}) #:nodoc:
+        #convert similar attributes
+        options[:handle] = ".#{options[:handle]}" if options[:handle]
+        if options[:tag] || options[:only]
+          options[:items] = "> "
+          options[:items] << options.delete(:tag) if options[:tag]
+          options[:items] << ".#{options.delete(:only)}" if options[:only]
+        end
+        options[:connectWith] = options.delete(:containment).map {|x| "##{x}"} if options[:containment]
+        options[:containment] = options.delete(:container) if options[:container]
+        options[:dropOnEmpty] = false unless options[:dropOnEmpty]
+        options[:helper] = "'clone'" if options[:ghosting] == true
+        options[:axis] = case options.delete(:constraint)
+          when "vertical", :vertical
+            "y"
+          when "horizontal", :horizontal
+            "x"
+          when false
+            nil
+          when nil
+            "y"
+        end
+        options.delete(:axis) if options[:axis].nil?
+        options.delete(:overlap)
+        options.delete(:ghosting)
+
+        if options[:onUpdate] || options[:url]
+          if options[:format]
+            options[:with] ||= "#{JQUERY_VAR}(this).sortable('serialize',{key:'#{element_id}[]', expression:#{options[:format]}})"
+            options.delete(:format)
+          else
+            options[:with] ||= "#{JQUERY_VAR}(this).sortable('serialize',{key:'#{element_id}[]'})"
+          end
+
+          options[:onUpdate] ||= "function(){" + remote_function(options) + "}"
+        end
+
+        options.delete_if { |key, value| JqueryHelper::AJAX_OPTIONS.include?(key) }
+        options[:update] = options.delete(:onUpdate) if options[:onUpdate]
+
+        [:axis, :cancel, :containment, :cursor, :handle, :tolerance, :items, :placeholder].each do |option|
+          options[option] = "'#{options[option]}'" if options[option]
+        end
+
+        options[:connectWith] = array_or_string_for_javascript(options[:connectWith]) if options[:connectWith]
+
+        %(#{JQUERY_VAR}('#{jquery_id(element_id)}').sortable(#{options_for_javascript(options)});)
+      end
+
+      def draggable_element_js(element_id, options = {})
+        %(#{JQUERY_VAR}("#{jquery_id(element_id)}").draggable(#{options_for_javascript(options)});)
+      end
+
+      def drop_receiving_element_js(element_id, options = {})
+        #convert similar options
+        options[:hoverClass] = options.delete(:hoverclass) if options[:hoverclass]
+        options[:drop] = options.delete(:onDrop) if options[:onDrop]
+
+        if options[:drop] || options[:url]
+          options[:with] ||= "'id=' + encodeURIComponent(#{JQUERY_VAR}(ui.draggable).attr('id'))"
+          options[:drop] ||= "function(ev, ui){" + remote_function(options) + "}"
+        end
+
+        options.delete_if { |key, value| JqueryHelper::AJAX_OPTIONS.include?(key) }
+
+        options[:accept] = array_or_string_for_javascript(options[:accept]) if options[:accept]
+        [:activeClass, :hoverClass, :tolerance].each do |option|
+          options[option] = "'#{options[option]}'" if options[option]
+        end
+
+        %(#{JQUERY_VAR}('#{jquery_id(element_id)}').droppable(#{options_for_javascript(options)});)
+      end
+
+      def array_or_string_for_javascript(option)
+        if option.kind_of?(Array)
+          "['#{option.join('\',\'')}']"
+        elsif !option.nil?
+          "'#{option}'"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/action_view/helpers/proxies.rb

@@ -0,0 +1,187 @@
+require 'action_view/helpers/proxies'
+
+module ActionView
+  module Helpers
+
+    # Converts chained method calls on DOM proxy elements into JavaScript chains
+    # copied from rails 3.0.20
+    class JavaScriptProxy < ActiveSupport::BasicObject #:nodoc:
+
+      def initialize(generator, root = nil)
+        @generator = generator
+        @generator << root if root
+      end
+
+      def is_a?(klass)
+        klass == JavaScriptProxy
+      end
+
+      private
+      def method_missing(method, *arguments, &block)
+        if method.to_s =~ /(.*)=$/
+          assign($1, arguments.first)
+        else
+          call("#{method.to_s.camelize(:lower)}", *arguments, &block)
+        end
+      end
+
+      def call(function, *arguments, &block)
+        append_to_function_chain!("#{function}(#{@generator.send(:arguments_for_call, arguments, block)})")
+        self
+      end
+
+      def assign(variable, value)
+        append_to_function_chain!("#{variable} = #{@generator.send(:javascript_object_for, value)}")
+      end
+
+      def function_chain
+        @function_chain ||= @generator.instance_variable_get(:@lines)
+      end
+
+      def append_to_function_chain!(call)
+        function_chain[-1].chomp!(';')
+        function_chain[-1] += ".#{call};"
+      end
+    end
+
+    # copied from rails 3.0.20
+    class JavaScriptCollectionProxy < JavaScriptProxy #:nodoc:
+      ENUMERABLE_METHODS_WITH_RETURN = [:all, :any, :collect, :map, :detect, :find, :find_all, :select, :max, :min, :partition, :reject, :sort_by, :in_groups_of, :each_slice] unless defined? ENUMERABLE_METHODS_WITH_RETURN
+      ENUMERABLE_METHODS = ENUMERABLE_METHODS_WITH_RETURN + [:each] unless defined? ENUMERABLE_METHODS
+      attr_reader :generator
+      delegate :arguments_for_call, :to => :generator
+
+      def initialize(generator, pattern)
+        super(generator, @pattern = pattern)
+      end
+
+      def each_slice(variable, number, &block)
+        if block
+          enumerate :eachSlice, :variable => variable, :method_args => [number], :yield_args => %w(value index), :return => true, &block
+        else
+          add_variable_assignment!(variable)
+          append_enumerable_function!("eachSlice(#{::ActiveSupport::JSON.encode(number)});")
+        end
+      end
+
+      def grep(variable, pattern, &block)
+        enumerate :grep, :variable => variable, :return => true, :method_args => [::ActiveSupport::JSON::Variable.new(pattern.inspect)], :yield_args => %w(value index), &block
+      end
+
+      def in_groups_of(variable, number, fill_with = nil)
+        arguments = [number]
+        arguments << fill_with unless fill_with.nil?
+        add_variable_assignment!(variable)
+        append_enumerable_function!("inGroupsOf(#{arguments_for_call arguments});")
+      end
+
+      def inject(variable, memo, &block)
+        enumerate :inject, :variable => variable, :method_args => [memo], :yield_args => %w(memo value index), :return => true, &block
+      end
+
+      def pluck(variable, property)
+        add_variable_assignment!(variable)
+        append_enumerable_function!("pluck(#{::ActiveSupport::JSON.encode(property)});")
+      end
+
+      def zip(variable, *arguments, &block)
+        add_variable_assignment!(variable)
+        append_enumerable_function!("zip(#{arguments_for_call arguments}")
+        if block
+          function_chain[-1] += ", function(array) {"
+          yield ::ActiveSupport::JSON::Variable.new('array')
+          add_return_statement!
+          @generator << '});'
+        else
+          function_chain[-1] += ');'
+        end
+      end
+
+      private
+      def method_missing(method, *arguments, &block)
+        if ENUMERABLE_METHODS.include?(method)
+          returnable = ENUMERABLE_METHODS_WITH_RETURN.include?(method)
+          enumerate(method, {:variable => (arguments.first if returnable), :return => returnable, :yield_args => %w(value index)}, &block)
+        else
+          super
+        end
+      end
+
+      # Options
+      #   * variable - name of the variable to set the result of the enumeration to
+      #   * method_args - array of the javascript enumeration method args that occur before the function
+      #   * yield_args - array of the javascript yield args
+      #   * return - true if the enumeration should return the last statement
+      def enumerate(enumerable, options = {}, &block)
+        options[:method_args] ||= []
+        options[:yield_args]  ||= []
+        yield_args  = options[:yield_args] * ', '
+        method_args = arguments_for_call options[:method_args] # foo, bar, function
+        method_args << ', ' unless method_args.blank?
+        add_variable_assignment!(options[:variable]) if options[:variable]
+        append_enumerable_function!("#{enumerable.to_s.camelize(:lower)}(#{method_args}function(#{yield_args}) {")
+        # only yield as many params as were passed in the block
+        yield(*options[:yield_args].collect { |p| JavaScriptVariableProxy.new(@generator, p) }[0..block.arity-1])
+        add_return_statement! if options[:return]
+        @generator << '});'
+      end
+
+      def add_variable_assignment!(variable)
+        function_chain.push("var #{variable} = #{function_chain.pop}")
+      end
+
+      def add_return_statement!
+        unless function_chain.last =~ /return/
+          function_chain.push("return #{function_chain.pop.chomp(';')};")
+        end
+      end
+
+      def append_enumerable_function!(call)
+        function_chain[-1].chomp!(';')
+        function_chain[-1] += ".#{call}"
+      end
+    end
+
+    class JavaScriptElementProxy < JavaScriptProxy #:nodoc:
+
+      JQUERY_VAR = ::JRails::JQUERY_VAR
+
+      def initialize(generator, id)
+        id = id.to_s.count('#.*,>+~:[/ ') == 0 ? "##{id}" : id
+        @id = id
+        super(generator, "#{JQUERY_VAR}(\"#{id}\")")
+      end
+
+      def replace_html(*options_for_render)
+        call 'html', @generator.send(:render, *options_for_render)
+      end
+
+      def replace(*options_for_render)
+        call 'replaceWith', @generator.send(:render, *options_for_render)
+      end
+
+      def reload(options_for_replace={})
+        replace(options_for_replace.merge({ :partial => @id.to_s.sub(/^#/,'') }))
+      end
+
+      def value()
+        call 'val()'
+      end
+
+      def value=(value)
+        call 'val', value
+      end
+
+    end
+
+    class JavaScriptElementCollectionProxy < JavaScriptCollectionProxy #:nodoc:\
+
+      JQUERY_VAR = ::JRails::JQUERY_VAR
+
+      def initialize(generator, pattern)
+        super(generator, "#{JQUERY_VAR}(#{pattern.to_json})")
+      end
+    end
+
+  end
+end

data/lib/action_view/helpers/scriptaculous_helper.rb

@@ -0,0 +1,263 @@
+require 'action_view/helpers/javascript_helper'
+require 'active_support/json'
+
+module ActionView
+  # = Action View Scriptaculous Helpers
+  module Helpers
+    # Provides a set of helpers for calling Scriptaculous[http://script.aculo.us/]
+    # JavaScript functions, including those which create Ajax controls and visual
+    # effects.
+    #
+    # To be able to use these helpers, you must include the Prototype
+    # JavaScript framework and the Scriptaculous JavaScript library in your
+    # pages. See the documentation for ActionView::Helpers::JavaScriptHelper
+    # for more information on including the necessary JavaScript.
+    #
+    # The Scriptaculous helpers' behavior can be tweaked with various options.
+    #
+    # See the documentation at http://script.aculo.us for more information on
+    # using these helpers in your application.
+    module ScriptaculousHelper
+      TOGGLE_EFFECTS = [:toggle_appear, :toggle_slide, :toggle_blind]
+
+      # Returns a JavaScript snippet to be used on the Ajax callbacks for
+      # starting visual effects.
+      #
+      # If no +element_id+ is given, it assumes "element" which should be a local
+      # variable in the generated JavaScript execution context. This can be
+      # used for example with +drop_receiving_element+:
+      #
+      #   <%= drop_receiving_element (...), :loading => visual_effect(:fade) %>
+      #
+      # This would fade the element that was dropped on the drop receiving
+      # element.
+      #
+      # For toggling visual effects, you can use <tt>:toggle_appear</tt>, <tt>:toggle_slide</tt>, and
+      # <tt>:toggle_blind</tt> which will alternate between appear/fade, slidedown/slideup, and
+      # blinddown/blindup respectively.
+      #
+      # You can change the behaviour with various options, see
+      # http://script.aculo.us for more documentation.
+      def visual_effect(name, element_id = false, js_options = {})
+        element = element_id ? ActiveSupport::JSON.encode(element_id) : "element"
+
+        js_options[:queue] = if js_options[:queue].is_a?(Hash)
+          '{' + js_options[:queue].map {|k, v| k == :limit ? "#{k}:#{v}" : "#{k}:'#{v}'" }.join(',') + '}'
+        elsif js_options[:queue]
+          "'#{js_options[:queue]}'"
+        end if js_options[:queue]
+
+        [:endcolor, :direction, :startcolor, :scaleMode, :restorecolor].each do |option|
+          js_options[option] = "'#{js_options[option]}'" if js_options[option]
+        end
+
+        if TOGGLE_EFFECTS.include? name.to_sym
+          "Effect.toggle(#{element},'#{name.to_s.gsub(/^toggle_/,'')}',#{options_for_javascript(js_options)});"
+        else
+          "new Effect.#{name.to_s.camelize}(#{element},#{options_for_javascript(js_options)});"
+        end
+      end
+
+      # Makes the element with the DOM ID specified by +element_id+ sortable
+      # by drag-and-drop and make an Ajax call whenever the sort order has
+      # changed. By default, the action called gets the serialized sortable
+      # element as parameters.
+      #
+      # Example:
+      #
+      #   <%= sortable_element("my_list", :url => { :action => "order" }) %>
+      #
+      # In the example, the action gets a "my_list" array parameter
+      # containing the values of the ids of elements the sortable consists
+      # of, in the current order.
+      #
+      # Important: For this to work, the sortable elements must have id
+      # attributes in the form "string_identifier". For example, "item_1". Only
+      # the identifier part of the id attribute will be serialized.
+      #
+      # Additional +options+ are:
+      #
+      # * <tt>:format</tt> - A regular expression to determine what to send as the
+      #   serialized id to the server (the default is <tt>/^[^_]*_(.*)$/</tt>).
+      #
+      # * <tt>:constraint</tt> - Whether to constrain the dragging to either
+      #   <tt>:horizontal</tt> or <tt>:vertical</tt> (or false to make it unconstrained).
+      #
+      # * <tt>:overlap</tt> - Calculate the item overlap in the <tt>:horizontal</tt>
+      #   or <tt>:vertical</tt> direction.
+      #
+      # * <tt>:tag</tt> - Which children of the container element to treat as
+      #   sortable (default is <tt>li</tt>).
+      #
+      # * <tt>:containment</tt> - Takes an element or array of elements to treat as
+      #   potential drop targets (defaults to the original target element).
+      #
+      # * <tt>:only</tt> - A CSS class name or array of class names used to filter
+      #   out child elements as candidates.
+      #
+      # * <tt>:scroll</tt> - Determines whether to scroll the list during drag
+      #   operations if the list runs past the visual border.
+      #
+      # * <tt>:tree</tt> - Determines whether to treat nested lists as part of the
+      #   main sortable list. This means that you can create multi-layer lists,
+      #   and not only sort items at the same level, but drag and sort items
+      #   between levels.
+      #
+      # * <tt>:hoverclass</tt> - If set, the Droppable will have this additional CSS class
+      #   when an accepted Draggable is hovered over it.
+      #
+      # * <tt>:handle</tt> - Sets whether the element should only be draggable by an
+      #   embedded handle. The value may be a string referencing a CSS class value
+      #   (as of script.aculo.us V1.5). The first child/grandchild/etc. element
+      #   found within the element that has this CSS class value will be used as
+      #   the handle.
+      #
+      # * <tt>:ghosting</tt> - Clones the element and drags the clone, leaving
+      #   the original in place until the clone is dropped (default is <tt>false</tt>).
+      #
+      # * <tt>:dropOnEmpty</tt> - If true the Sortable container will be made into
+      #   a Droppable, that can receive a Draggable (as according to the containment
+      #   rules) as a child element when there are no more elements inside (default
+      #   is <tt>false</tt>).
+      #
+      # * <tt>:onChange</tt> - Called whenever the sort order changes while dragging. When
+      #   dragging from one Sortable to another, the callback is called once on each
+      #   Sortable. Gets the affected element as its parameter.
+      #
+      # * <tt>:onUpdate</tt> - Called when the drag ends and the Sortable's order is
+      #   changed in any way. When dragging from one Sortable to another, the callback
+      #   is called once on each Sortable. Gets the container as its parameter.
+      #
+      # See http://script.aculo.us for more documentation.
+      def sortable_element(element_id, options = {})
+        javascript_tag(sortable_element_js(element_id, options).chop!)
+      end
+
+      def sortable_element_js(element_id, options = {}) #:nodoc:
+        options[:with]     ||= "Sortable.serialize(#{ActiveSupport::JSON.encode(element_id)})"
+        options[:onUpdate] ||= "function(){" + remote_function(options) + "}"
+        options.delete_if { |key, value| PrototypeHelper::AJAX_OPTIONS.include?(key) }
+
+        [:tag, :overlap, :constraint, :handle].each do |option|
+          options[option] = "'#{options[option]}'" if options[option]
+        end
+
+        options[:containment] = array_or_string_for_javascript(options[:containment]) if options[:containment]
+        options[:only] = array_or_string_for_javascript(options[:only]) if options[:only]
+
+        %(Sortable.create(#{ActiveSupport::JSON.encode(element_id)}, #{options_for_javascript(options)});)
+      end
+
+      # Makes the element with the DOM ID specified by +element_id+ draggable.
+      #
+      # Example:
+      #   <%= draggable_element("my_image", :revert => true)
+      #
+      # You can change the behaviour with various options, see
+      # http://script.aculo.us for more documentation.
+      def draggable_element(element_id, options = {})
+        javascript_tag(draggable_element_js(element_id, options).chop!)
+      end
+
+      def draggable_element_js(element_id, options = {}) #:nodoc:
+        %(new Draggable(#{ActiveSupport::JSON.encode(element_id)}, #{options_for_javascript(options)});)
+      end
+
+      # Makes the element with the DOM ID specified by +element_id+ receive
+      # dropped draggable elements (created by +draggable_element+).
+      # and make an AJAX call. By default, the action called gets the DOM ID
+      # of the element as parameter.
+      #
+      # Example:
+      #   <%= drop_receiving_element("my_cart", :url =>
+      #     { :controller => "cart", :action => "add" }) %>
+      #
+      # You can change the behaviour with various options, see
+      # http://script.aculo.us for more documentation.
+      #
+      # Some of these +options+ include:
+      # * <tt>:accept</tt> - Set this to a string or an array of strings describing the
+      #   allowable CSS classes that the +draggable_element+ must have in order
+      #   to be accepted by this +drop_receiving_element+.
+      #
+      # * <tt>:confirm</tt> - Adds a confirmation dialog. Example:
+      #
+      #     :confirm => "Are you sure you want to do this?"
+      #
+      # * <tt>:hoverclass</tt> - If set, the +drop_receiving_element+ will have
+      #   this additional CSS class when an accepted +draggable_element+ is
+      #   hovered over it.
+      #
+      # * <tt>:onDrop</tt> - Called when a +draggable_element+ is dropped onto
+      #   this element. Override this callback with a JavaScript expression to
+      #   change the default drop behaviour. Example:
+      #
+      #     :onDrop => "function(draggable_element, droppable_element, event) { alert('I like bananas') }"
+      #
+      #   This callback gets three parameters: The Draggable element, the Droppable
+      #   element and the Event object. You can extract additional information about
+      #   the drop - like if the Ctrl or Shift keys were pressed - from the Event object.
+      #
+      # * <tt>:with</tt> - A JavaScript expression specifying the parameters for
+      #   the XMLHttpRequest. Any expressions should return a valid URL query string.
+      def drop_receiving_element(element_id, options = {})
+        javascript_tag(drop_receiving_element_js(element_id, options).chop!)
+      end
+
+      def drop_receiving_element_js(element_id, options = {}) #:nodoc:
+        options[:with]     ||= "'id=' + encodeURIComponent(element.id)"
+        options[:onDrop]   ||= "function(element){" + remote_function(options) + "}"
+        options.delete_if { |key, value| PrototypeHelper::AJAX_OPTIONS.include?(key) }
+
+        options[:accept] = array_or_string_for_javascript(options[:accept]) if options[:accept]
+        options[:hoverclass] = "'#{options[:hoverclass]}'" if options[:hoverclass]
+
+        # Confirmation happens during the onDrop callback, so it can be removed from the options
+        options.delete(:confirm) if options[:confirm]
+
+        %(Droppables.add(#{ActiveSupport::JSON.encode(element_id)}, #{options_for_javascript(options)});)
+      end
+
+      protected
+        def array_or_string_for_javascript(option)
+          if option.kind_of?(Array)
+            "['#{option.join('\',\'')}']"
+          elsif !option.nil?
+            "'#{option}'"
+          end
+        end
+    end
+
+    module PrototypeHelper
+      class JavaScriptGenerator
+        module GeneratorMethods
+          # Starts a script.aculo.us visual effect. See
+          # ActionView::Helpers::ScriptaculousHelper for more information.
+          def visual_effect(name, id = nil, options = {})
+            record @context.send(:visual_effect, name, id, options)
+          end
+
+          # Creates a script.aculo.us sortable element. Useful
+          # to recreate sortable elements after items get added
+          # or deleted.
+          # See ActionView::Helpers::ScriptaculousHelper for more information.
+          def sortable(id, options = {})
+            record @context.send(:sortable_element_js, id, options)
+          end
+
+          # Creates a script.aculo.us draggable element.
+          # See ActionView::Helpers::ScriptaculousHelper for more information.
+          def draggable(id, options = {})
+            record @context.send(:draggable_element_js, id, options)
+          end
+
+          # Creates a script.aculo.us drop receiving element.
+          # See ActionView::Helpers::ScriptaculousHelper for more information.
+          def drop_receiving(id, options = {})
+            record @context.send(:drop_receiving_element_js, id, options)
+          end
+        end
+      end
+    end
+  end
+end