compages 0.4.0

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

@@ -0,0 +1,23 @@
+class UJS::BehaviourScriptConverter
+  def initialize(script)
+    @script = script
+  end
+  
+  # Converts a BehaviourScript object into a custom hash format
+  def self.convert_to_hash(script)
+    self.new(script).to_hash
+  end
+  
+  # Converts a hash-converted BehaviourScript back to a BehaviourScript again
+  def self.convert_from_hash(script_hash)
+    script = UJS::BehaviourScript.new(script_hash[:options][:cache], script_hash[:options][:reapply_after_ajax])
+    script_hash[:rules].each { |r| script.add_rule(r[0], r[1]) }
+    script
+  end
+  
+  # Convert behaviour script to a hash
+  def to_hash
+    { :options => { :cache => @script.cache?, :reapply_after_ajax => @script.reapply_after_ajax? },
+      :rules => @script.rules }
+  end
+end

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

@@ -0,0 +1,55 @@
+module UJS::ControllerMethods
+  def self.included(base)
+    base.class_eval do
+      before_filter :store_controller_for_helpers
+      before_filter :initialise_js_behaviours 
+      after_filter  :store_js_behaviours
+    end
+  end
+  
+  # Lets you register javascript behaviours from within
+  # the controller. For a description of the different options
+  # available, see UJS::Helpers#apply_behaviour (note: 
+  # this function does not take a block like the view helper version)
+  def apply_behaviour(selector, behaviour, opts={})
+    opts.reverse_merge!(:prevent_default => false)
+    @js_behaviours.add_rule(selector, behaviour, opts[:prevent_default])
+  end
+  
+  def cache_behaviours
+    @js_behaviours.enable_cache
+  end
+  
+  def reapply_behaviours_after_ajax=(val)
+    @js_behaviours.reapply_after_ajax = val
+  end
+  
+  # Make American and English spellings both work for apply_behaviour
+  alias_method :apply_behavior, :apply_behaviour
+
+  protected
+    # Initialises the javascript behaviours
+    def initialise_js_behaviours
+      @js_behaviours = UJS::BehaviourScript.new(@cache_behaviours)
+    end
+  
+    # Clears the array of registered javascript behaviours
+    def reset_js_behaviours
+      session[:js_behaviours] = nil
+    end
+    
+    # Returns a BehaviourScript from the behaviours serialized to the session
+    def js_behaviours
+      return nil if session[:js_behaviours].nil?
+      UJS::BehaviourScriptConverter.convert_from_hash(session[:js_behaviours])
+    end
+    
+    # Stores all registered javascript behaviours in the session as a hash
+    def store_js_behaviours
+      session[:js_behaviours] = @js_behaviours.to_hash
+    end
+    
+    def store_controller_for_helpers
+      ActionView::Helpers.current_controller = self
+    end
+end

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

@@ -0,0 +1,152 @@
+require File.dirname(__FILE__) + '/behaviour_helper'
+require File.dirname(__FILE__) + '/javascript_proxies'
+
+module UJS::Helpers
+  include UJS::BehaviourHelper
+  include UJS::JavascriptProxies
+  
+  # This is the core functionality of the plugin;
+  # it allows you to attach javascript behaviour to your page
+  # elements in an unobtrusive fashion. It takes three options:
+  # * +selector+ - CSS selector and event. For a full overview of
+  #   the selector syntax, see the event:Selectors website.
+  #   http://encytemedia.com/event-selectors
+  # * +behaviour+ - The javascript that you want to attach to the element
+  #   and event specified by +selector+ as a string of javascript.
+  # * +opts+ - A hash of additional options.
+  #
+  # Attaching a behaviour to an element on your page is as simple as
+  # specifying the element and the event you want the behaviour attached
+  # to, using the CSS selector format, and passing in a string of javascript:
+  #
+  #  <% apply_behaviour "#coollink:click", "alert('Hello World')" %>
+  #
+  # You can also make use of any of the built-in Rails helpers that
+  # generate Javascript:
+  #
+  #  <% apply_behaviour "#coolink:click", visual_effect(:highlight, "coollink") %>
+  #
+  # You will have access to two javascript variables inside your javascript string:
+  # * +this+: returns a reference to the HTML element that the behaviour was attached to
+  # * +event+: the event the behaviour was attached to:
+  #
+  #  <% apply_behaviour "#coollink:click", "alert('You clicked '  this.id); Event.stop(event)" %>
+  #
+  # The following options can be set using the opts hash:
+  #
+  # * <tt>:external</tt> - If true, the behaviour will be attached to the external behaviour file.
+  #   If false, it will be rendered directly in the page inside +script+ tags. Defaults to true.
+  #
+  # When setting <tt>:external</tt> to false, you <em>must</em> call the register_js_behaviour from
+  # within ERb <em>output</em> blocks. If <tt>:external</tt> is true, you can use either output or non-output blocks.
+  #
+  # If you set :prevent_default to true the default action of the event is stopped (similar to calling event.stop).
+  # This is very useful for hijacking links in order to provide some other behaviour.
+  #
+  # You can also pass a block to the function instead of a string of javascript - 
+  # the block will be passed in a JavascriptGenerator object (+page+), the element (optional) 
+  # and the event (optional). You can use the Javascript generator
+  # to write your attached behaviour using Ruby:
+  #
+  #  <% apply_behaviour "#coollink:click" do |page, element, event|
+  #       page.alert("Hi there, I'm going to fade away...")
+  #       page.visual_effect :fade, element
+  #     end %>
+  def apply_behaviour(selector, *args, &block) #:yields: page, element, event
+    opts = args.last.is_a?(Hash) ? args.pop : {}
+    set_default_external!(opts)
+    behaviour = normalise_behaviour_string(args.first || '')
+        
+    if block_given?
+      generator = new_javascript_generator
+      args = [generator, element_proxy(generator), event_proxy(generator)][0..block.arity-1]
+      @template.instance_exec(*args, &block)
+      behaviour = generator.to_s
+    end
+    
+    if !opts[:external]
+      render_inline_behaviour_block(selector, behaviour, opts)
+    else
+      @controller.apply_behaviour(selector, behaviour, opts) and return ''
+    end
+  end
+  
+  # Allow you to apply multiple behaviours with block syntax.
+  #
+  #   apply_behaviours do 
+  #     on 'a:click', 'alert("boo")'
+  #     on 'abbr:mouseover', 'showAbbr(this)'
+  #   end
+  def apply_behaviours(&block)
+    mapper = BehaviourMapper.new(self).instance_eval &block
+    mapper.to_s
+  end
+    
+  # Make sure American and English spellings both work
+  alias_method :apply_behavior, :apply_behaviour
+  alias_method :apply_behaviors, :apply_behaviours
+  
+  protected
+    # A convenient mapper class for applying
+    # multiple behaviours at once.
+    class BehaviourMapper
+      def initialize(base)
+        @base = base
+        @output = ''
+      end
+      
+      def on(*args, &block)
+        @output << @base.apply_behaviour(*args, &block)
+      end
+      
+      # delegate all other method calls to the view
+      def method_missing(meth, *args)
+        @base.send meth, *args
+      end
+      
+      def to_s
+        @output
+      end
+      
+    end
+  
+    # Renders a block of javascript behaviours inside +script+ tags 
+    # directly within the page 
+    def render_inline_behaviour_block(selector, behaviour, opts)
+      script = UJS::BehaviourScript.new
+      script.add_rule(selector, behaviour)
+      javascript_tag(script.to_s)
+    end
+  
+    # Use this to set the default :external option for helper calls.
+    # it set external to false if its an xhr request or false if it's a normal request.
+    def set_default_external!(options)
+      options.reverse_merge!(:external => !current_controller.request.xhr?)
+    end
+    
+    # Returns a new JavascriptArgumentProxy for the element the behaviour
+    # has been applied to.
+    def element_proxy(generator)
+      UJS::JavascriptProxies::JavascriptArgumentProxy.new(UJS::JavascriptProxies::ReferencedJavascriptElementProxy, generator, 'this')
+    end
+    
+    # Returns a new JavascriptArgumentProxy for the event the behaviour has
+    # been applied to.
+    def event_proxy(generator)
+      UJS::JavascriptProxies::JavascriptArgumentProxy.new(UJS::JavascriptProxies::JavascriptEventProxy, generator, 'event')
+    end
+    
+    # Returns a new JavasScriptGenerator object
+    def new_javascript_generator
+      ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(@template) {  }
+    end
+    
+    def current_controller
+      @controller
+    end
+    
+    def normalise_behaviour_string(behaviour)
+      behaviour << ';' unless behaviour =~ /;$/
+      behaviour
+    end
+end

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

@@ -0,0 +1,57 @@
+module ActionView
+  module Helpers
+    class JavaScriptProxy
+      public :method_missing
+      
+      protected 
+      
+      def wrap(function, *args)
+        args = [function_chain[-1].chomp(';')].concat(args.collect(&:to_json)).join(', ')
+        replace_line("#{function.to_s}(#{args});")
+      end
+      
+      def replace_line(new_line)
+        function_chain[-1] = new_line
+      end
+      
+    end
+  end
+end
+
+
+module UJS
+  module JavascriptProxies
+    
+    class ReferencedJavascriptElementProxy < ActionView::Helpers::JavaScriptElementProxy
+      
+      def initialize(generator, var)
+        @generator = generator
+        @generator << var
+      end
+      
+      def reload; end
+      
+    end
+      
+    class JavascriptArgumentProxy
+      def initialize(proxy, *contructor_args)
+        @proxy, @args = proxy, contructor_args
+      end
+      
+      def method_missing(meth, *args)
+        proxy = @proxy.new(*@args)
+        proxy.__send__(meth, *args)
+      end
+    end
+    
+    class JavascriptEventProxy < ActionView::Helpers::JavaScriptProxy
+      def stop
+        wrap('Event.stop')
+      end
+      
+      def element
+        wrap('Event.element')
+      end
+    end 
+  end
+end

data/vendor/plugins/unobtrusive_javascript/tasks/unobtrusive_javascript_tasks.rake

@@ -0,0 +1,15 @@
+namespace :unobtrusive_javascript do
+  
+  PLUGIN_ROOT = File.dirname(__FILE__) + '/../'
+  
+  desc 'Installs required javascript files to the public/javascripts directory.'
+  task :install do
+    FileUtils.cp Dir[PLUGIN_ROOT + '/assets/javascripts/*.js'], RAILS_ROOT + '/public/javascripts'
+  end
+
+  desc 'Removes the javascripts for the plugin.'
+  task :remove do
+    FileUtils.rm %{lowpro.js}.collect { |f| RAILS_ROOT + "/public/javascripts/" + f  }
+  end
+  
+end

data/vendor/plugins/unobtrusive_javascript/test/asset_tag_helper_patches_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'asset_tag_helper_patches'
+
+class JavascriptIncludeTagWithUnobtrusiveOption < Test::Unit::TestCase
+  include ActionView::Helpers::AssetTagHelper
+  include ActionView::Helpers::TagHelper
+  
+  def setup
+    initialize_test_request
+    @output = javascript_include_tag(:unobtrusive).split("\n")
+  end
+  
+  def test_should_render_script_tag_for_lowpro
+    assert @output.include?('<script src="/javascripts/lowpro.js?" type="text/javascript"></script>')
+  end
+  
+  def test_should_render_script_tag_for_current_requests_behaviour
+    assert @output.include?('<script src="/behaviours/controller_stub.js?" type="text/javascript"></script>')
+  end
+  
+  def test_should_render_index_behaviour_when_request_path_is_just_a_forward_slash
+    @controller.request.stubs(:path).returns('/')
+    @output = javascript_include_tag(:unobtrusive).split("\n")
+    assert @output.include?('<script src="/behaviours/index.js?" type="text/javascript"></script>')
+  end
+  
+  def test_should_render_index_behaviour_when_request_path_is_blank_as_a_result_of_a_url_prefix
+    @controller.request.stubs(:path).returns('')
+    @output = javascript_include_tag(:unobtrusive).split("\n")
+    assert @output.include?('<script src="/behaviours/index.js?" type="text/javascript"></script>')
+  end
+end

data/vendor/plugins/unobtrusive_javascript/test/behaviour_helper_test.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'prototype_helper_patches'
+require 'scriptaculous_helper_patches'
+require 'ujs/behaviour_helper'
+
+class MakeSortableTest < Test::Unit::TestCase
+  include ActionView::Helpers::JavaScriptHelper
+  include ActionView::Helpers::ScriptaculousHelper
+  include ActionView::Helpers::PrototypeHelper
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include UJS::BehaviourHelper
+  
+  def setup
+    initialize_test_request
+  end
+  
+  def test_should_output_sortable_javascript
+    output = make_sortable
+    
+    assert_equal sortable_element_js(javascript_variable('this')), output
+  end
+  
+  def test_should_pass_arguments_through
+    output = make_sortable :onUpdate => 'function() { alert("updated") }'
+    assert_equal 'Sortable.create(this, {onUpdate:function() { alert("updated") }});', output
+  end
+end
+
+class MakeRemoteLinkTest < Test::Unit::TestCase
+  include ActionView::Helpers::JavaScriptHelper
+  include ActionView::Helpers::ScriptaculousHelper
+  include ActionView::Helpers::PrototypeHelper
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include UJS::BehaviourHelper
+  
+  def setup
+    initialize_test_request
+  end
+  
+  def test_should_generate_ajax_request
+    output = make_remote_link
+    assert_match(/new Ajax\.Request/, output)
+  end
+  
+  def test_should_default_to_element_href
+    output = make_remote_link
+    assert_match(/\(this\.href/, output)
+  end
+  
+  def test_should_respond_to_given_options
+    output = make_remote_link( :update => 'fartknocker' )
+    assert_match(/new Ajax\.Updater\('fartknocker'/, output)
+  end
+end
+
+class MakeRemoteFormTest < Test::Unit::TestCase
+  include ActionView::Helpers::JavaScriptHelper
+  include ActionView::Helpers::ScriptaculousHelper
+  include ActionView::Helpers::PrototypeHelper
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include UJS::BehaviourHelper
+  
+  def setup
+    initialize_test_request
+  end
+  
+  def test_should_generate_ajax_request
+    output = make_remote_form
+    assert_match(/new Ajax\.Request/, output)
+  end
+  
+  def test_should_default_to_form_action
+    output = make_remote_form
+    assert_match(/\(this\.action/, output)
+  end
+end
+
+class MakeDraggableTest < Test::Unit::TestCase
+  include ActionView::Helpers::JavaScriptHelper
+  include ActionView::Helpers::ScriptaculousHelper
+  include ActionView::Helpers::PrototypeHelper
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include UJS::BehaviourHelper
+  
+  def setup
+    initialize_test_request
+  end
+  
+  def test_should_create_draggable_instance
+    output = make_draggable
+    assert_match(/new Draggable/, output)
+  end
+  
+  def test_should_pass_this
+    output = make_draggable
+    assert_match(/\(this/, output)
+  end
+  
+  def test_should_respond_to_options
+    output = make_draggable( :revert => true )
+    assert_match(/revert\:true/, output)
+  end
+end
+
+class MakeDropRecievingTest < Test::Unit::TestCase
+  include ActionView::Helpers::JavaScriptHelper
+  include ActionView::Helpers::ScriptaculousHelper
+  include ActionView::Helpers::PrototypeHelper
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include UJS::BehaviourHelper
+  
+  def setup
+    initialize_test_request
+  end
+  
+  def test_should_add_to_droppables
+    output = make_drop_receiving
+    assert_match(/Droppables\.add/, output)
+  end
+  
+  def test_should_pass_this
+    output = make_drop_receiving
+    assert_match(/\(this/, output)
+  end
+  
+  def test_should_generate_a_url_from_options
+    output = make_drop_receiving( :url => { :action => "bingo" } )
+    assert_match(/controller_stub\/bingo/, output)
+  end
+end
+
+class MakeObservedTest < Test::Unit::TestCase
+  include ActionView::Helpers::JavaScriptHelper
+  include ActionView::Helpers::ScriptaculousHelper
+  include ActionView::Helpers::PrototypeHelper
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include UJS::BehaviourHelper
+  
+  def setup
+    initialize_test_request
+  end
+  
+  def test_should_make_form_observer
+    output = make_observed(:form)
+    assert_match(/new Form\.EventObserver/, output)
+  end
+  
+  def test_should_make_field_observer
+    output = make_observed(:field)
+    assert_match(/new Form\.Element\.EventObserver/, output)
+  end
+  
+  def test_should_pass_this
+    output = make_observed(:field)
+    assert_match(/\(this/, output)
+  end
+  
+  def test_should_make_a_timed_observer_if_frequency_passed
+    output = make_observed(:form, :frequency => 3 )
+    assert_match(/new Form.Observer/, output)
+    assert_match(/3,/, output)
+  end
+  
+  def test_should_generate_a_url_from_options
+    output = make_observed(:field, :url => { :action => "bingo" } )
+    assert_match(/controller_stub\/bingo/, output)
+  end
+  
+  def test_should_respond_to_options
+    output = make_observed(:field, :function => 'alert("boo")' )
+    assert_match(/function\(element, value\) \{alert\("boo"\)\}/, output)
+  end
+end
+