compages 0.4.0

data/vendor/plugins/unobtrusive_javascript/lib/asset_tag_helper_patches.rb

@@ -0,0 +1,33 @@
+module ActionView::Helpers::AssetTagHelper
+  alias_method :rails_javascript_include_tag, :javascript_include_tag
+  
+  # Adds a new option to Rails' built-in <tt>javascript_include_tag</tt>
+  # helper - <tt>:unobtrusive</tt>. Works in the same way as <tt>:defaults</tt> - specifying 
+  # <tt>:unobtrusive</tt> will make sure the necessary javascript
+  # libraries and behaviours file +script+ tags are loaded. Will happily
+  # work along side <tt>:defaults</tt>.
+  #
+  #  <%= javascript_include_tag :defaults, :unobtrusive %>
+  #
+  # This replaces the old +unobtrusive_javascript_files+ helper.
+  def javascript_include_tag(*sources)
+   if sources.delete :unobtrusive
+     sources = sources.concat(
+       ['lowpro', behaviours_url]
+     ).uniq
+   end
+   rails_javascript_include_tag(*sources)
+  end
+  
+  protected  
+    def behaviours_url
+      action_path = case @controller.request.path
+        when '', '/'
+          '/index'
+        else
+          @controller.request.path
+      end
+      "/behaviours#{action_path}.js"
+    end
+end
+

data/vendor/plugins/unobtrusive_javascript/lib/behaviour_caching.rb

@@ -0,0 +1,70 @@
+module UJS
+  module BehaviourCaching
+    
+    def self.included(base)
+      base.extend ControllerClassMethods
+    end
+    
+    attr_accessor :cache_behaviours
+
+    module ControllerClassMethods
+      
+      # Also file caching of the behaviour for hidden actions.  This actually
+      # write the javascript file into the public directory (or given cache dir)
+      # in the same style as page caching.  Which means requests for the behaviour
+      # will not hit the application at all.  Use this for reasonably static behaviours.
+      #
+      # NB. If you use caches_page or caches_action your behaviours will automatically ne
+      # cached in this way.  expire_page and expire_action also automatically expire the 
+      # cached behaviour.
+      #
+      #   caches_behaviour :index, :register
+      #
+      # See expire_behaviour to expire cached behaviours.
+      def caches_behaviour(*actions)
+        actions.each do |action|
+          class_eval "prepend_before_filter { |c| c.cache_behaviours = (c.action_name == '#{action}') }"
+        end
+      end
+      
+      alias_method :caches_behavior, :caches_behaviour
+      
+      def caches_page(*actions)
+        caches_behaviour(*actions)
+        super
+      end
+      
+      def caches_action(*actions)
+        caches_behaviour(*actions)
+        super
+      end
+      
+    end
+    
+    # Expires the behaviours for the given url options.
+    #
+    #     expire_behaviour :action => 'index'
+    def expire_behaviour(options={})
+      self.class.expire_page "/behaviour#{url_for(options)}.js"
+    end
+    
+    alias_method :expire_behavior, :expire_behaviour
+    
+    def expire_page(options={})
+      expire_behaviour(options)
+      super
+    end
+    
+    def expire_action(options={})
+      if options[:action].is_a?(Array)
+        options[:action].dup.each do |action|
+          expire_behaviour(options.merge({ :action => action }))
+        end
+      else
+        expire_behaviour(options)
+      end
+      super
+    end
+    
+  end
+end

data/vendor/plugins/unobtrusive_javascript/lib/controllers/unobtrusive_javascript_controller.rb

@@ -0,0 +1,52 @@
+require 'digest/md5'
+
+class UnobtrusiveJavascriptController < ActionController::Base
+  skip_before_filter :initialise_js_behaviours
+  skip_after_filter  :store_js_behaviours
+  
+  after_filter :perform_any_caching 
+  after_filter :reset_js_behaviours
+  
+  # Renders the external javascript behaviours file
+  # with the appropriate content-type.
+  def generate
+    headers['Content-Type'] = 'text/javascript'
+    
+    if js_behaviours
+      generate_etag
+      modified? ? render_script : render_304
+    else
+      render :text => "", :layout => false
+    end
+  end 
+  
+  protected
+  
+  def perform_any_caching
+    if behaviour_caching_enabled?
+      self.class.cache_page js_behaviours.to_s, request.path
+    end
+  end
+  
+  private
+  
+  def generate_etag
+    headers['ETag'] = Digest::MD5.hexdigest(js_behaviours.to_s)
+  end
+  
+  def modified?
+    request.env['HTTP_IF_NONE_MATCH'] != headers['ETag']
+  end
+  
+  def render_script
+    render :text => js_behaviours.to_s, :layout => false
+  end
+  
+  def render_304
+    render :nothing => true, :status => 304
+  end
+  
+  def behaviour_caching_enabled?
+    js_behaviours && js_behaviours.cache?
+  end
+end

data/vendor/plugins/unobtrusive_javascript/lib/prototype_helper_patches.rb

@@ -0,0 +1,72 @@
+module ActionView::Helpers::PrototypeHelper
+  
+  class JavaScriptRef
+    def initialize(ref); @ref = ref; end
+    def to_json; @ref; end
+  end
+  
+  def javascript_variable(name)
+    JavaScriptRef.new(name)
+  end
+  
+  def build_observer(klass, name, options={})
+    set_default_external!(options)
+    javascript = build_observer_js(klass, name, options)
+    
+    unless options.delete :external
+      javascript_tag(javascript)
+    else
+      @controller.apply_behaviour("##{name}", javascript)
+      return ''
+    end
+  end
+  
+  def build_observer_js(klass, name, options)
+    if options[:with] && !options[:with].include?("=")
+      options[:with] = "'#{options[:with]}=' + value"
+    else
+      options[:with] ||= 'value' if options[:update]
+    end
+
+    callback = options[:function] || remote_function(options)
+    javascript  = "new #{klass}(#{name.to_json}, "
+    javascript << "#{options[:frequency]}, " if options[:frequency]
+    javascript << "function(element, value) {"
+    javascript << "#{callback}}"
+    javascript << ", '#{options[:on]}'" if options[:on]
+    javascript << ")"
+    javascript
+  end
+  
+  def remote_function(options)
+    javascript_options = options_for_ajax(options)
+
+    update = ''
+    if options[:update] and options[:update].is_a?Hash
+      update  = []
+      update << "success:'#{options[:update][:success]}'" if options[:update][:success]
+      update << "failure:'#{options[:update][:failure]}'" if options[:update][:failure]
+      update  = '{' + update.join(',') + '}'
+    elsif options[:update]
+      update << "'#{options[:update]}'"
+    end
+
+    function = update.empty? ? 
+      "new Ajax.Request(" :
+      "new Ajax.Updater(#{update}, "
+
+    url_options = options[:url]
+    url_options = url_options.merge(:escape => false) if url_options.is_a? Hash
+    url = url_options.is_a?(JavaScriptRef) ? url_options.to_json : "'#{url_for(url_options)}'"
+    function << "#{url}"
+    function << ", #{javascript_options})"
+
+    function = "#{options[:before]}; #{function}" if options[:before]
+    function = "#{function}; #{options[:after]}"  if options[:after]
+    function = "if (#{options[:condition]}) { #{function}; }" if options[:condition]
+    function = "if (confirm('#{escape_javascript(options[:confirm])}')) { #{function}; }" if options[:confirm]
+
+    return function
+  end
+  
+end

data/vendor/plugins/unobtrusive_javascript/lib/scriptaculous_helper_patches.rb

@@ -0,0 +1,62 @@
+module ActionView::Helpers::ScriptaculousHelper  
+  def draggable_element(element_id, options={})
+    set_default_external!(options)
+    external = options.delete :external
+    prepare_script(element_id, draggable_element_js(element_id, options).chop!, external)
+  end
+  
+  def draggable_element_js(element_id, options = {}) #:nodoc:
+    %(new Draggable(#{element_id.to_json}, #{options_for_javascript(options)});)
+  end
+  
+  def drop_recieving_element(element_id, options={})
+    set_default_external!(options)
+    external = options.delete :external
+    prepare_script(element_id, drop_receiving_element_js(element_id, options).chop!, external)
+  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| ActionView::Helpers::PrototypeHelper::AJAX_OPTIONS.include?(key) }
+
+    options[:accept] = array_or_string_for_javascript(options[:accept]) if options[:accept]    
+    options[:hoverclass] = "'#{options[:hoverclass]}'" if options[:hoverclass]
+    
+    %(Droppables.add(#{element_id.to_json}, #{options_for_javascript(options)});)
+  end
+  
+  def sortable_element(element_id, options={})
+    set_default_external!(options)
+    external = options.delete :external
+    prepare_script(element_id, sortable_element_js(element_id, options).chop!, external)
+  end
+  
+  def sortable_element_js(element_id, options = {}) #:nodoc:
+    options[:with]     ||= "Sortable.serialize(#{element_id.to_json})"
+    options[:onUpdate] ||= "function(){" + remote_function(options) + "}"
+    options.delete_if { |key, value| ActionView::Helpers::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(#{element_id.to_json}, #{options_for_javascript(options)});)
+  end
+  
+  protected
+  
+  def prepare_script(element_id, js, external=true)
+    unless external
+      javascript_tag(js)
+    else
+      @controller.apply_behaviour "##{element_id}", js
+      return ''
+    end
+  end
+  
+end
+

data/vendor/plugins/unobtrusive_javascript/lib/tag_helper_patches.rb

@@ -0,0 +1,37 @@
+module ActionView::Helpers::TagHelper
+  include UJS::Helpers
+  
+  JAVASCRIPT_EVENTS = %w(click mouseup mousedown dblclick mousemove mouseover mouseout submit change keypress keyup keydown load)
+  
+  alias_method :rails_tag_options, :tag_options
+
+  protected
+    # Patch to the built-in Rails tag_options method. Looks for any
+    # javascript event handlers, extracts them and registers them
+    # as unobtrusive behaviours.
+    #
+    # This behaviour affects any built-in Rails helpers that generate
+    # HTML. Event extraction behaviour can be bypassed by passing in
+    # <tt>:inline => true</tt> as part of a helper's HTML options hash.
+    def tag_options(opts)
+      set_default_external!(opts)
+      if opts[:external]
+        JAVASCRIPT_EVENTS.each do |event|
+          unless opts["on#{event}"].blank?
+            opts['id'] = generate_html_id unless opts['id']
+            apply_behaviour("##{opts['id']}:#{event}", opts["on#{event}"]) unless opts["on#{event}"].nil?
+            opts.delete("on#{event}")
+          end
+        end
+        opts.delete(:external)
+      end
+      rails_tag_options(opts)
+    end
+
+    # Generate a unique id to be used as the HTML +id+ attribute.
+    def generate_html_id
+      @tag_counter ||= 0
+      @tag_counter = @tag_counter.next
+      "#{UJS::Settings.generated_id_prefix}#{@tag_counter}"
+    end
+end

data/vendor/plugins/unobtrusive_javascript/lib/ujs.rb

@@ -0,0 +1,32 @@
+module UJS
+  PLUGIN_NAME = 'unobtrusive_javascript'
+  PLUGIN_PATH = "#{RAILS_ROOT}/vendor/plugins/#{PLUGIN_NAME}"
+  PLUGIN_ASSET_PATH = "#{PLUGIN_PATH}/assets"
+  PLUGIN_CONTROLLER_PATH = "#{PLUGIN_PATH}/lib/controllers"
+  
+  class Settings
+    # All elements with attached behaviours that do not
+    # have an HTML +id+ attribute will have one
+    # generated automatically, using the form _prefix_x_,
+    # where the default prefix is "uj_element_" and x is an
+    # automatically incremented number. You can set the
+    # generated prefix to anything you like by setting it in your
+    # environment.rb file:
+    #
+    #   UJS::Settings.generated_id_prefix = "my_prefix_"
+    cattr_accessor :generated_id_prefix
+    @@generated_id_prefix = "uj_element_"
+  end
+  
+  class << self
+    # Adds routes to your application necessary for the plugin to function correctly.
+    # Simply add the following inside your Routes.draw block in routes.rb:
+    #   UJS::routes
+    # This is now *mandatory*.
+    def routes
+      ActionController::Routing::Routes.add_route "/behaviours/*page_path", :controller => "unobtrusive_javascript", :action => "generate"
+    end
+    
+    alias_method :use_fake_script_links, :routes
+  end
+end

data/vendor/plugins/unobtrusive_javascript/lib/ujs/behaviour_helper.rb

@@ -0,0 +1,62 @@
+module UJS
+  # The helper methods in this module can all be passed as arguments to apply_behaviour and allow
+  # you to reproduce common functionailty such as drag and drop and sorting in a simple way.  Think
+  # of them as the apply_javascript equivilent to the Scriptaculous helpers.
+  #
+  # Usage:
+  #
+  #    apply_behaviour '.products', make_draggable
+  #    apply_behaviour '.help', make_remote_link( :action => 'showhelp' )
+  #    apply_behaviour '.todolist', make_sortable
+  #
+  module BehaviourHelper    
+    
+    # Make a link send an Ajax request.  options identical to linkt_to_remote except that
+    # :url defaults to the href attribute of the link.
+    def make_remote_link(options={})
+      options[:url] ||= javascript_variable('this.href');
+      "this.observe('click', function(event) {\n#{remote_function(options)};\nreturn false;\n});"
+    end
+    
+    # Make a form submit via an Ajax request.  options identical remote_form except that
+    # :url defaults to the action attribute of the form.
+    def make_remote_form(options={})
+      options[:url] ||= javascript_variable('this.action');
+      options[:with] ||= 'Form.serialize(this)'
+      "this.observe('submit', function(event) {\n#{remote_function(options)};\nreturn false;\n});"
+    end
+    
+    # Observe a form or form field (specified with the type argument) using the given options
+    # which are the same as observe_form and observe_field.
+    def make_observed(type, options={})
+      obs = (type.to_s == 'form') ? 'Form' : 'Form.Element'
+      if options[:frequency] && options[:frequency] > 0
+        build_observer_js("#{obs}.Observer", javascript_variable('this'), options)
+      else
+        build_observer_js("#{obs}.EventObserver", javascript_variable('this'), options)
+      end
+    end
+  
+    # Makes the children of the element sortable.
+    def make_sortable(options={})
+      sortable_element_js(javascript_variable('this'), options)
+    end
+    
+    # Makes the element draggable.
+    def make_draggable(options={})
+      draggable_element_js(javascript_variable('this'), options)
+    end
+    
+    # Makes the element a drop target.
+    def make_drop_receiving(options={})
+      drop_receiving_element_js(javascript_variable('this'), options)
+    end
+    
+    def make_autocomplete # :nodoc:
+    end
+    
+    def make_in_place_editor # :nodoc:
+    end
+    
+  end
+end

data/vendor/plugins/unobtrusive_javascript/lib/ujs/behaviour_script.rb

@@ -0,0 +1,54 @@
+class UJS::BehaviourScript
+  attr_reader :rules
+  attr_writer :reapply_after_ajax
+  
+  def initialize(cache=false, reapply_after_ajax=true)
+    @rules, @cache, @reapply_after_ajax = [], cache, reapply_after_ajax
+  end
+  
+  def add_rule(selector, javascript, cancel_default=false)
+    javascript = javascript << cancel_default_js if cancel_default
+    @rules << [selector, javascript]
+  end
+  
+  def cache?
+    @cache
+  end
+  
+  def enable_cache
+    @cache = true
+  end
+  
+  def reapply_after_ajax?
+    @reapply_after_ajax
+  end
+  
+  # Renders behaviour block and option JavaScript.
+  def to_s
+    (@rules && !@rules.empty?) ? "Event.addBehavior({\n#{rule_js}\n});" + option_js : ''
+  end
+  
+  # Uses behaviour script converter to conver to a hash for session storage
+  def to_hash
+    UJS::BehaviourScriptConverter.convert_to_hash(self)
+  end
+  
+  protected  
+    # Renders a collection of behaviour rules in javascript format
+    def rule_js
+      @rules.uniq.collect { |sel, js| behaviour_rule(sel, js) }.join(",\n")
+    end
+  
+    # Renders behaviour rule javascript for the behaviours file
+    def behaviour_rule(selector, behaviour)
+      "\"#{selector}\": function(event) {\n#{behaviour}\n}"
+    end
+  
+    def option_js
+      reapply_after_ajax? ? '' : "\nEvent.addBehavior.reapplyAfterAjax = false;"
+    end
+    
+    def cancel_default_js
+      " return false;"
+    end
+end