actionpack 1.9.1 → 1.10.1

data/lib/action_view/helpers/javascripts/slider.js

@@ -0,0 +1,258 @@
+// Copyright (c) 2005 Marty Haught
+// 
+// See scriptaculous.js for full license.
+
+if(!Control) var Control = {};
+Control.Slider = Class.create();
+
+// options:
+//  axis: 'vertical', or 'horizontal' (default)
+//  increment: (default: 1)
+//  step: (default: 1)
+//
+// callbacks:
+//  onChange(value)
+//  onSlide(value)
+Control.Slider.prototype = {
+  initialize: function(handle, track, options) {
+    this.handle  = $(handle);
+    this.track   = $(track);
+
+    this.options = options || {};
+
+    this.axis      = this.options.axis || 'horizontal';
+    this.increment = this.options.increment || 1;
+    this.step      = parseInt(this.options.step) || 1;
+    this.value     = 0;
+
+    var defaultMaximum = Math.round(this.track.offsetWidth / this.increment);
+    if(this.isVertical()) defaultMaximum = Math.round(this.track.offsetHeight / this.increment);   
+    
+    this.maximum = this.options.maximum || defaultMaximum;
+    this.minimum = this.options.minimum || 0;
+
+    // Will be used to align the handle onto the track, if necessary
+    this.alignX = parseInt (this.options.alignX) || 0;
+    this.alignY = parseInt (this.options.alignY) || 0;
+
+    // Zero out the slider position	
+    this.setCurrentLeft(Position.cumulativeOffset(this.track)[0] - Position.cumulativeOffset(this.handle)[0] + this.alignX);
+    this.setCurrentTop(this.trackTop() - Position.cumulativeOffset(this.handle)[1] + this.alignY);
+
+    this.offsetX = 0;
+    this.offsetY = 0;
+
+    this.originalLeft = this.currentLeft();
+    this.originalTop  = this.currentTop();
+    this.originalZ    = parseInt(this.handle.style.zIndex || "0");
+
+    // Prepopulate Slider value
+    this.setSliderValue(parseInt(this.options.sliderValue) || 0);
+
+    this.active   = false;
+    this.dragging = false;
+    this.disabled = false;
+
+    // FIXME: use css
+    this.handleImage    = $(this.options.handleImage) || false; 
+    this.handleDisabled = this.options.handleDisabled || false;
+    this.handleEnabled  = false;
+    if(this.handleImage)
+      this.handleEnabled  = this.handleImage.src || false;
+
+    if(this.options.disabled)
+      this.setDisabled();
+
+    // Value Array
+    this.values = this.options.values || false;  // Add method to validate and sort??
+
+    Element.makePositioned(this.handle); // fix IE
+
+    this.eventMouseDown = this.startDrag.bindAsEventListener(this);
+    this.eventMouseUp   = this.endDrag.bindAsEventListener(this);
+    this.eventMouseMove = this.update.bindAsEventListener(this);
+    this.eventKeypress  = this.keyPress.bindAsEventListener(this);
+
+    Event.observe(this.handle, "mousedown", this.eventMouseDown);
+    Event.observe(document, "mouseup", this.eventMouseUp);
+    Event.observe(document, "mousemove", this.eventMouseMove);
+    Event.observe(document, "keypress", this.eventKeypress);
+  },
+  dispose: function() {
+    Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
+    Event.stopObserving(document, "mouseup", this.eventMouseUp);
+    Event.stopObserving(document, "mousemove", this.eventMouseMove);
+    Event.stopObserving(document, "keypress", this.eventKeypress);
+  },
+  setDisabled: function(){
+    this.disabled = true;
+    if(this.handleDisabled)
+      this.handleImage.src = this.handleDisabled;
+  },
+  setEnabled: function(){
+    this.disabled = false;
+    if(this.handleEnabled)
+      this.handleImage.src = this.handleEnabled;
+  },  
+  currentLeft: function() {
+    return parseInt(this.handle.style.left || '0');
+  },
+  currentTop: function() {
+    return parseInt(this.handle.style.top || '0');
+  },
+  setCurrentLeft: function(left) {
+    this.handle.style.left = left +"px";
+  },
+  setCurrentTop: function(top) {
+    this.handle.style.top = top +"px";
+  },
+  trackLeft: function(){
+    return Position.cumulativeOffset(this.track)[0];
+  },
+  trackTop: function(){
+    return Position.cumulativeOffset(this.track)[1];
+  }, 
+  getNearestValue: function(value){
+    if(this.values){
+      var i = 0;
+      var offset = Math.abs(this.values[0] - value);
+      var newValue = this.values[0];
+
+      for(i=0; i < this.values.length; i++){
+        var currentOffset = Math.abs(this.values[i] - value);
+        if(currentOffset < offset){
+          newValue = this.values[i];
+          offset = currentOffset;
+        }
+      }
+      return newValue;
+    }
+    return value;
+  },
+  setSliderValue:  function(sliderValue){
+    // First check our max and minimum and nearest values
+    sliderValue = this.getNearestValue(sliderValue);	
+    if(sliderValue > this.maximum) sliderValue = this.maximum;
+    if(sliderValue < this.minimum) sliderValue = this.minimum;
+    var offsetDiff = (sliderValue - (this.value||this.minimum)) * this.increment;
+    
+    if(this.isVertical()){
+      this.setCurrentTop(offsetDiff + this.currentTop());
+    } else {
+      this.setCurrentLeft(offsetDiff + this.currentLeft());
+    }
+    this.value = sliderValue;
+    this.updateFinished();
+  },  
+  minimumOffset: function(){
+    return(this.isVertical() ? 
+      this.trackTop() + this.alignY :
+      this.trackLeft() + this.alignX);
+  },
+  maximumOffset: function(){
+    return(this.isVertical() ?
+      this.trackTop() + this.alignY + (this.maximum - this.minimum) * this.increment :
+      this.trackLeft() + this.alignX + (this.maximum - this.minimum) * this.increment);
+  },  
+  isVertical:  function(){
+    return (this.axis == 'vertical');
+  },
+  startDrag: function(event) {
+    if(Event.isLeftClick(event)) {
+      if(!this.disabled){
+        this.active = true;
+        var pointer = [Event.pointerX(event), Event.pointerY(event)];
+        var offsets = Position.cumulativeOffset(this.handle);
+        this.offsetX =  (pointer[0] - offsets[0]);
+        this.offsetY =  (pointer[1] - offsets[1]);
+        this.originalLeft = this.currentLeft();
+        this.originalTop = this.currentTop();
+      }
+      Event.stop(event);
+    }
+  },
+  update: function(event) {
+   if(this.active) {
+      if(!this.dragging) {
+        var style = this.handle.style;
+        this.dragging = true;
+        if(style.position=="") style.position = "relative";
+        style.zIndex = this.options.zindex;
+      }
+      this.draw(event);
+      // fix AppleWebKit rendering
+      if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
+      Event.stop(event);
+   }
+  },
+  draw: function(event) {
+    var pointer = [Event.pointerX(event), Event.pointerY(event)];
+    var offsets = Position.cumulativeOffset(this.handle);
+
+    offsets[0] -= this.currentLeft();
+    offsets[1] -= this.currentTop();
+        
+    // Adjust for the pointer's position on the handle
+    pointer[0] -= this.offsetX;
+    pointer[1] -= this.offsetY;
+    var style = this.handle.style;
+
+    if(this.isVertical()){
+      if(pointer[1] > this.maximumOffset())
+        pointer[1] = this.maximumOffset();
+      if(pointer[1] < this.minimumOffset())
+        pointer[1] =  this.minimumOffset();
+
+    // Increment by values
+    if(this.values){
+      this.value = this.getNearestValue(Math.round((pointer[1] - this.minimumOffset()) / this.increment) + this.minimum);
+      pointer[1] = this.trackTop() + this.alignY + (this.value - this.minimum) * this.increment;
+    } else {
+      this.value = Math.round((pointer[1] - this.minimumOffset()) / this.increment) + this.minimum;
+    }
+    style.top  = pointer[1] - offsets[1] + "px";
+    } else {
+      if(pointer[0] > this.maximumOffset()) pointer[0] = this.maximumOffset();
+      if(pointer[0] < this.minimumOffset())	pointer[0] =  this.minimumOffset();
+      // Increment by values
+      if(this.values){
+        this.value = this.getNearestValue(Math.round((pointer[0] - this.minimumOffset()) / this.increment) + this.minimum);
+        pointer[0] = this.trackLeft() + this.alignX + (this.value - this.minimum) * this.increment;
+      } else {
+        this.value = Math.round((pointer[0] - this.minimumOffset()) / this.increment) + this.minimum;
+      }
+      style.left = (pointer[0] - offsets[0]) + "px";
+    }
+    if(this.options.onSlide) this.options.onSlide(this.value);
+  },
+  endDrag: function(event) {
+    if(this.active && this.dragging) {
+      this.finishDrag(event, true);
+      Event.stop(event);
+    }
+    this.active = false;
+    this.dragging = false;
+  },  
+  finishDrag: function(event, success) {
+    this.active = false;
+    this.dragging = false;
+    this.handle.style.zIndex = this.originalZ;
+    this.originalLeft = this.currentLeft();
+    this.originalTop  = this.currentTop();
+    this.updateFinished();
+  },
+  updateFinished: function() {
+    if(this.options.onChange) this.options.onChange(this.value);
+  },
+  keyPress: function(event) {
+    if(this.active && !this.disabled) {
+      switch(event.keyCode) {
+        case Event.KEY_ESC:
+          this.finishDrag(event, false);
+          Event.stop(event); 
+          break;
+      }
+      if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
+    }
+  }
+}

data/lib/action_view/helpers/number_helper.rb

@@ -4,8 +4,8 @@ module ActionView
     # one of the following forms: phone number, percentage, money, or precision level.
     module NumberHelper
 
-      # Formats a +number+ into a US phone number string. The +options+ can be hash used to customize the format of the output.
-      # The area code can be surrounded by parenthesis by setting +:area_code+ to true; default is false
+      # Formats a +number+ into a US phone number string. The +options+ can be a hash used to customize the format of the output.
+      # The area code can be surrounded by parentheses by setting +:area_code+ to true; default is false
       # The delimiter can be set using +:delimiter+; default is "-"
       # Examples:
       #   number_to_phone(1235551234)   => 123-555-1234
@@ -25,7 +25,7 @@ module ActionView
         end
       end
 
-      # Formates a +number+ into a currency string. The +options+ hash can be used to customize the format of the output.
+      # Formats a +number+ into a currency string. The +options+ hash can be used to customize the format of the output.
       # The +number+ can contain a level of precision using the +precision+ key; default is 2
       # The currency type can be set using the +unit+ key; default is "$"
       # The unit separator can be set using the +separator+ key; default is "."
@@ -37,6 +37,7 @@ module ActionView
       def number_to_currency(number, options = {})
         options = options.stringify_keys
         precision, unit, separator, delimiter = options.delete("precision") { 2 }, options.delete("unit") { "$" }, options.delete("separator") { "." }, options.delete("delimiter") { "," }
+        separator = "" unless precision > 0
         begin
           parts = number_with_precision(number, precision).split('.')
           unit + number_with_delimiter(parts[0], delimiter) + separator + parts[1].to_s

data/lib/action_view/helpers/pagination_helper.rb

@@ -18,7 +18,8 @@ module ActionView
         }
       end
 
-      # Creates a basic HTML link bar for the given +paginator+. 
+      # Creates a basic HTML link bar for the given +paginator+.
+      # +html_options+ are passed to +link_to+.
       #
       # +options+ are:
       # <tt>:name</tt>::                 the routing name for this paginator
@@ -33,39 +34,53 @@ module ActionView
       #                                  +false+)
       # <tt>:params</tt>::               any additional routing parameters
       #                                  for page URLs
-      def pagination_links(paginator, options={})
-        options.merge!(DEFAULT_OPTIONS) {|key, old, new| old}
+      def pagination_links(paginator, options={}, html_options={})
+        name = options[:name] || DEFAULT_OPTIONS[:name]
+        params = (options[:params] || DEFAULT_OPTIONS[:params]).clone
         
-        window_pages = paginator.current.window(options[:window_size]).pages
+        pagination_links_each(paginator, options) do |n|
+          params[name] = n
+          link_to(n.to_s, params, html_options)
+        end
+      end
+
+      # Iterate through the pages of a given +paginator+, invoking a
+      # block for each page number that needs to be rendered as a link.
+      def pagination_links_each(paginator, options)
+        options = DEFAULT_OPTIONS.merge(options)
+        link_to_current_page = options[:link_to_current_page]
+        always_show_anchors = options[:always_show_anchors]
 
-        return if window_pages.length <= 1 unless
-          options[:link_to_current_page]
+        current_page = paginator.current_page
+        window_pages = current_page.window(options[:window_size]).pages
+        return if window_pages.length <= 1 unless link_to_current_page
         
         first, last = paginator.first, paginator.last
         
-        returning html = '' do
-          if options[:always_show_anchors] and not window_pages[0].first?
-            html << link_to(first.number, { options[:name] => first }.update( options[:params] ))
-            html << ' ... ' if window_pages[0].number - first.number > 1
-            html << ' '
-          end
-          
-          window_pages.each do |page|
-            if paginator.current == page && !options[:link_to_current_page]
-              html << page.number.to_s
-            else
-              html << link_to(page.number, { options[:name] => page }.update( options[:params] ))
-            end
-            html << ' '
-          end
+        html = ''
+        if always_show_anchors and not (wp_first = window_pages[0]).first?
+          html << yield(first.number)
+          html << ' ... ' if wp_first.number - first.number > 1
+          html << ' '
+        end
           
-          if options[:always_show_anchors] && !window_pages.last.last?
-            html << ' ... ' if last.number - window_pages[-1].number > 1
-            html << link_to(paginator.last.number, { options[:name] => last }.update( options[:params]))
+        window_pages.each do |page|
+          if current_page == page && !link_to_current_page
+            html << page.number.to_s
+          else
+            html << yield(page.number)
           end
+          html << ' '
         end
+        
+        if always_show_anchors and not (wp_last = window_pages[-1]).last? 
+          html << ' ... ' if last.number - wp_last.number > 1
+          html << yield(last.number)
+        end
+        
+        html
       end
       
-    end
-  end
-end
+    end # PaginationHelper
+  end # Helpers
+end # ActionView

data/lib/action_view/helpers/tag_helper.rb

@@ -10,27 +10,41 @@ module ActionView
       # Examples:
       # * <tt>tag("br") => <br /></tt>
       # * <tt>tag("input", { "type" => "text"}) => <input type="text" /></tt>
-      def tag(name, options = {}, open = false)
-        "<#{name}#{tag_options(options)}" + (open ? ">" : " />")
+      def tag(name, options = nil, open = false)
+        "<#{name}#{tag_options(options.stringify_keys) if options}" + (open ? ">" : " />")
       end
 
       # Examples:
       # * <tt>content_tag("p", "Hello world!") => <p>Hello world!</p></tt>
       # * <tt>content_tag("div", content_tag("p", "Hello world!"), "class" => "strong") => </tt>
       #   <tt><div class="strong"><p>Hello world!</p></div></tt>
-      def content_tag(name, content, options = {})
-        "<#{name}#{tag_options(options)}>#{content}</#{name}>"
+      def content_tag(name, content, options = nil)
+        "<#{name}#{tag_options(options.stringify_keys) if options}>#{content}</#{name}>"
+      end
+
+      # Returns a CDATA section for the given +content+.  CDATA sections
+      # are used to escape blocks of text containing characters which would
+      # otherwise be recognized as markup. CDATA sections begin with the string
+      # <tt>&lt;![CDATA[</tt> and end with (and may not contain) the string 
+      # <tt>]]></tt>. 
+      def cdata_section(content)
+        "<![CDATA[#{content}]]>"
       end
 
       private
         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
+          cleaned_options = convert_booleans(options.stringify_keys.reject {|key, value| value.nil?})
+          ' ' + cleaned_options.map {|key, value| %(#{key}="#{html_escape(value.to_s)}")}.sort * ' ' unless cleaned_options.empty?
+        end
+
+        def convert_booleans(options)
+          %w( disabled readonly multiple ).each { |a| boolean_attribute(options, a) }
+          options
+        end
+
+        def boolean_attribute(options, attribute)
+          options[attribute] ? options[attribute] = attribute : options.delete(attribute)
         end
     end
   end
-end
+end

data/lib/action_view/helpers/text_helper.rb

@@ -3,14 +3,14 @@ require File.dirname(__FILE__) + '/tag_helper'
 module ActionView
   module Helpers #:nodoc:
     # Provides a set of methods for working with text strings that can help unburden the level of inline Ruby code in the
-    # templates. In the example below we iterate over a collection of posts provided to the template and prints each title
+    # templates. In the example below we iterate over a collection of posts provided to the template and print each title
     # after making sure it doesn't run longer than 20 characters:
     #   <% for post in @posts %>
     #     Title: <%= truncate(post.title, 20) %>
     #   <% end %>
-    module TextHelper
+    module TextHelper      
       # The regular puts and print are outlawed in eRuby. It's recommended to use the <%= "hello" %> form instead of print "hello".
-      # If you absolutely must use a method-based output, you can use concat. It's use like this <% concat "hello", binding %>. Notice that
+      # If you absolutely must use a method-based output, you can use concat. It's used like this: <% concat "hello", binding %>. Notice that
       # it doesn't have an equal sign in front. Using <%= concat "hello" %> would result in a double hello.
       def concat(string, binding)
         eval("_erbout", binding).concat(string)
@@ -20,7 +20,13 @@ module ActionView
       # if the +text+ is longer than +length+.
       def truncate(text, length = 30, truncate_string = "...")
         if text.nil? then return end
-        if text.length > length then text[0..(length - 3)] + truncate_string else text end
+
+        if $KCODE == "NONE"
+          text.length > length ? text[0..(length - 3)] + truncate_string : text
+        else
+          chars = text.split(//)
+          chars.length > length ? chars[0..(length-3)].join + truncate_string : text
+        end
       end
 
       # Highlights the +phrase+ where it is found in the +text+ by surrounding it like
@@ -29,7 +35,7 @@ module ActionView
       # N.B.: The +phrase+ is sanitized to include only letters, digits, and spaces before use.
       def highlight(text, phrase, highlighter = '<strong class="highlight">\1</strong>')
         if phrase.blank? then return text end
-        text.gsub(/(#{escape_regexp(phrase)})/i, highlighter) unless text.nil?
+        text.gsub(/(#{Regexp.escape(phrase)})/i, highlighter) unless text.nil?
       end
 
       # Extracts an excerpt from the +text+ surrounding the +phrase+ with a number of characters on each side determined
@@ -37,7 +43,7 @@ module ActionView
       #   excerpt("hello my world", "my", 3) => "...lo my wo..."
       def excerpt(text, phrase, radius = 100, excerpt_string = "...")
         if text.nil? || phrase.nil? then return end
-        phrase = escape_regexp(phrase)
+        phrase = Regexp.escape(phrase)
 
         if found_pos = text =~ /(#{phrase})/i
           start_pos = [ found_pos - radius, 0 ].max
@@ -76,7 +82,13 @@ module ActionView
         # Returns the text with all the Textile codes turned into HTML-tags.
         # <i>This method is only available if RedCloth can be required</i>.
         def textilize(text)
-          text.blank? ? "" : RedCloth.new(text, [ :hard_breaks ]).to_html
+          if text.blank?
+            ""
+          else
+            textilized = RedCloth.new(text, [ :hard_breaks ])
+            textilized.hard_breaks = true if textilized.respond_to?("hard_breaks=")
+            textilized.to_html
+          end
         end
 
         # Returns the text with all the Textile codes turned into HTML-tags, but without the regular bounding <p> tag.
@@ -103,7 +115,7 @@ module ActionView
         # We can't really help what's not there
       end
       
-      # Returns +text+ transformed into html using very simple formatting rules
+      # Returns +text+ transformed into HTML using very simple formatting rules
       # Surrounds paragraphs with <tt>&lt;p&gt;</tt> tags, and converts line breaks into <tt>&lt;br /&gt;</tt>
       # Two consecutive newlines(<tt>\n\n</tt>) are considered as a paragraph, one newline (<tt>\n</tt>) is
       # considered a linebreak, three or more consecutive newlines are turned into two newlines 
@@ -189,18 +201,112 @@ module ActionView
 
         html
       end
+      
+      # Returns a Cycle object whose to_s value cycles through items of an
+      # array every time it is called. This can be used to alternate classes
+      # for table rows:
+      #
+      # <%- for item in @items do -%>
+      #   <tr class="<%= cycle("even", "odd") %>">
+      #     ... use item ...
+      #   </tr>
+      # <%- end -%>
+      #
+      # You can use named cycles to prevent clashes in nested loops.  You'll
+      # have to reset the inner cycle, manually:
+      #
+      # <%- for item in @items do -%>
+      #   <tr class="<%= cycle("even", "odd", :name => "row_class")
+      #     <td>
+      #       <%- for value in item.values do -%>
+      #         <span style="color:'<%= cycle("red", "green", "blue"
+      #                                       :name => "colors") %>'">
+      #           item
+      #         </span>
+      #       <%- end -%>
+      #       <%- reset_cycle("colors") -%>
+      #     </td>
+      #   </tr>
+      # <%- end -%>
+      def cycle(first_value, *values)
+        if (values.last.instance_of? Hash)
+          params = values.pop
+          name = params[:name]
+        else
+          name = "default"
+        end
+        values.unshift(first_value)
 
+        cycle = get_cycle(name)
+        if (cycle.nil? || cycle.values != values)
+          cycle = set_cycle(name, Cycle.new(*values))
+        end
+        return cycle.to_s
+      end
+      
+      # Resets a cycle so that it starts from the first element in the array
+      # the next time it is used.
+      def reset_cycle(name = "default")
+        cycle = get_cycle(name)
+        return if cycle.nil?
+        cycle.reset
+      end
+
+      class Cycle #:nodoc:
+        attr_reader :values
+        
+        def initialize(first_value, *values)
+          @values = values.unshift(first_value)
+          reset
+        end
+        
+        def reset
+          @index = 0
+        end
+
+        def to_s
+          value = @values[@index].to_s
+          @index = (@index + 1) % @values.size
+          return value
+        end
+      end
       
       private
-        # Returns a version of the text that's safe to use in a regular expression without triggering engine features.
-        def escape_regexp(text)
-          text.gsub(/([\\|?+*\/\)\(])/) { |m| "\\#{$1}" }
+        # The cycle helpers need to store the cycles in a place that is
+        # guaranteed to be reset every time a page is rendered, so it
+        # uses an instance variable of ActionView::Base.
+        def get_cycle(name)
+          @_cycles = Hash.new if @_cycles.nil?
+          return @_cycles[name]
         end
+        
+        def set_cycle(name, cycle_object)
+          @_cycles = Hash.new if @_cycles.nil?
+          @_cycles[name] = cycle_object
+        end
+      
+        AUTO_LINK_RE = /
+                        (                       # leading text
+                          <\w+.*?>|             #   leading HTML tag, or
+                          [^=!:'"\/]|           #   leading punctuation, or 
+                          ^                     #   beginning of line
+                        )
+                        (
+                          (?:http[s]?:\/\/)|    # protocol spec, or
+                          (?:www\.)             # www.*
+                        ) 
+                        (
+                          ([\w]+[=?&\/.-]?)*    # url segment
+                          \w+[\/]?              # url tail
+                          (?:\#\w*)?            # trailing anchor
+                        )
+                        ([[:punct:]]|\s|<|$)    # trailing text
+                       /x unless const_defined?(:AUTO_LINK_RE)
 
         # Turns all urls into clickable links.
         def auto_link_urls(text, href_options = {})
-          text.gsub(/(<\w+.*?>|[^=!:'"\/]|^)((?:http[s]?:\/\/)|(?:www\.))([^\s<]+\/?)([[:punct:]]|\s|<|$)/) do
-            all, a, b, c, d = $&, $1, $2, $3, $4
+          text.gsub(AUTO_LINK_RE) do
+            all, a, b, c, d = $&, $1, $2, $3, $5
             if a =~ /<a\s/i # don't replace URL's that are already linked
               all
             else