rq 3.4.0 → 3.5.0

data/rails/vendor/rails/actionpack/lib/action_view/helpers/scriptaculous_helper.rb

@@ -1,140 +0,0 @@
-require File.dirname(__FILE__) + '/javascript_helper'
-
-module ActionView
-  module Helpers
-    # Provides a set of helpers for calling Scriptaculous 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
-      unless const_defined? :TOGGLE_EFFECTS
-        TOGGLE_EFFECTS = [:toggle_appear, :toggle_slide, :toggle_blind]
-      end
-      
-      # Returns a JavaScript snippet to be used on the Ajax callbacks for
-      # starting visual effects.
-      #
-      # Example:
-      #   <%= link_to_remote "Reload", :update => "posts", 
-      #         :url => { :action => "reload" }, 
-      #         :complete => visual_effect(:highlight, "posts", :duration => 0.5)
-      #
-      # 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_receving_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 :toggle_appear, :toggle_slide, and
-      # :toggle_blind 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 ? element_id.to_json : "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]
-        
-        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.
-      #
-      #
-      # You can change the behaviour with various options, 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(#{element_id.to_json})"
-        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(#{element_id.to_json}, #{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(#{element_id.to_json}, #{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.
-      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]
-        
-        %(Droppables.add(#{element_id.to_json}, #{options_for_javascript(options)});)
-      end
-    end
-  end
-end

data/rails/vendor/rails/actionpack/lib/action_view/helpers/tag_helper.rb

@@ -1,103 +0,0 @@
-require 'cgi'
-require 'erb'
-
-module ActionView
-  module Helpers #:nodoc:
-    # Use these methods to generate HTML tags programmatically when you can't use
-    # a Builder. By default, they output XHTML compliant tags.
-    module TagHelper
-      include ERB::Util
-
-      # Returns an empty HTML tag of type +name+ which by default is XHTML 
-      # compliant. Setting +open+ to true will create an open tag compatible 
-      # with HTML 4.0 and below. Add HTML attributes by passing an attributes 
-      # hash to +options+. For attributes with no value like (disabled and 
-      # readonly), give it a value of true in the +options+ hash. You can use
-      # symbols or strings for the attribute names.
-      #
-      #   tag("br")
-      #    # => <br />
-      #   tag("br", nil, true)
-      #    # => <br>
-      #   tag("input", { :type => 'text', :disabled => true }) 
-      #    # => <input type="text" disabled="disabled" />
-      def tag(name, options = nil, open = false)
-        "<#{name}#{tag_options(options) if options}" + (open ? ">" : " />")
-      end
-
-      # Returns an HTML block tag of type +name+ surrounding the +content+. Add
-      # HTML attributes by passing an attributes hash to +options+. For attributes 
-      # with no value like (disabled and readonly), give it a value of true in 
-      # the +options+ hash. You can use symbols or strings for the attribute names.
-      #
-      #   content_tag(:p, "Hello world!")
-      #    # => <p>Hello world!</p>
-      #   content_tag(:div, content_tag(:p, "Hello world!"), :class => "strong")
-      #    # => <div class="strong"><p>Hello world!</p></div>
-      #   content_tag("select", options, :multiple => true)
-      #    # => <select multiple="multiple">...options...</select>
-      #
-      # Instead of passing the content as an argument, you can also use a block
-      # in which case, you pass your +options+ as the second parameter.
-      #
-      #   <% content_tag :div, :class => "strong" do -%>
-      #     Hello world!
-      #   <% end -%>
-      #    # => <div class="strong"><p>Hello world!</p></div>
-      def content_tag(name, content_or_options_with_block = nil, options = nil, &block)
-        if block_given?
-          options = content_or_options_with_block if content_or_options_with_block.is_a?(Hash)
-          content = capture(&block)
-          concat(content_tag_string(name, content, options), block.binding)
-        else
-          content = content_or_options_with_block
-          content_tag_string(name, content, options)
-        end
-      end
-
-      # Returns a CDATA section with 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><![CDATA[</tt> and end with (and may not contain) the string <tt>]]></tt>.
-      #
-      #   cdata_section("<hello world>")
-      #    # => <![CDATA[<hello world>]]>
-      def cdata_section(content)
-        "<![CDATA[#{content}]]>"
-      end
-
-      # Returns the escaped +html+ without affecting existing escaped entities.
-      #
-      #   escape_once("1 > 2 &amp; 3")
-      #    # => "1 &lt; 2 &amp; 3"
-      def escape_once(html)
-        fix_double_escape(html_escape(html.to_s))
-      end
-
-      private
-        def content_tag_string(name, content, options)
-          tag_options = options ? tag_options(options) : ""
-          "<#{name}#{tag_options}>#{content}</#{name}>"
-        end
-      
-        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
-
-        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
-        
-        # Fix double-escaped entities, such as &amp;amp;, &amp;#123;, etc.
-        def fix_double_escape(escaped)
-          escaped.gsub(/&amp;([a-z]+|(#\d+));/i) { "&#{$1};" }
-        end
-    end
-  end
-end

data/rails/vendor/rails/actionpack/lib/action_view/helpers/text_helper.rb

@@ -1,406 +0,0 @@
-require File.dirname(__FILE__) + '/tag_helper'
-
-module ActionView
-  module Helpers #:nodoc:
-    # The TextHelper Module provides a set of methods for filtering, formatting 
-    # and transforming strings that can reduce the amount of inline Ruby code in 
-    # your views. These helper methods extend ActionView making them callable 
-    # within your template files as shown in the following example which truncates
-    # the title of each post to 10 characters.
-    #
-    #   <% @posts.each do |post| %>
-    #     # post == 'This is my title'
-    #     Title: <%= truncate(post.title, 10) %>
-    #   <% end %>
-    #    => Title: This is my...
-    module TextHelper      
-      # The preferred method of outputting text in your views is to use the 
-      # <%= "text" %> eRuby syntax. The regular _puts_ and _print_ methods 
-      # do not operate as expected in an eRuby code block. If you absolutely must 
-      # output text within a code block, you can use the concat method.
-      #
-      #   <% concat "hello", binding %>
-      # is equivalent to using:
-      #   <%= "hello" %>
-      def concat(string, binding)
-        eval("_erbout", binding).concat(string)
-      end
-
-      # If +text+ is longer than +length+, +text+ will be truncated to the length of 
-      # +length+ and the last three characters will be replaced with the +truncate_string+.
-      #
-      #   truncate("Once upon a time in a world far far away", 14)  
-      #    => Once upon a...
-      def truncate(text, length = 30, truncate_string = "...")
-        if text.nil? then return end
-        l = length - truncate_string.chars.length
-        text.chars.length > length ? text.chars[0...l] + truncate_string : text
-      end
-
-      # Highlights +phrase+ everywhere it is found in +text+ by inserting it into
-      # a +highlighter+ string. The highlighter can be specialized by passing +highlighter+ 
-      # as a single-quoted string with \1 where the phrase is to be inserted.
-      #
-      #   highlight('You searched for: rails', 'rails')  
-      #    => You searched for: <strong class="highlight">rails</strong>
-      def highlight(text, phrase, highlighter = '<strong class="highlight">\1</strong>')
-        if phrase.blank? then return text end
-        text.gsub(/(#{Regexp.escape(phrase)})/i, highlighter) unless text.nil?
-      end
-
-      # Extracts an excerpt from +text+ that matches the first instance of +phrase+. 
-      # The +radius+ expands the excerpt on each side of +phrase+ by the number of characters
-      # defined in +radius+. If the excerpt radius overflows the beginning or end of the +text+,
-      # then the +excerpt_string+ will be prepended/appended accordingly. If the +phrase+ 
-      # isn't found, nil is returned.
-      #
-      #   excerpt('This is an example', 'an', 5) 
-      #    => "...s is an examp..."
-      #
-      #   excerpt('This is an example', 'is', 5) 
-      #    => "This is an..."
-      def excerpt(text, phrase, radius = 100, excerpt_string = "...")
-        if text.nil? || phrase.nil? then return end
-        phrase = Regexp.escape(phrase)
-
-        if found_pos = text.chars =~ /(#{phrase})/i
-          start_pos = [ found_pos - radius, 0 ].max
-          end_pos   = [ found_pos + phrase.chars.length + radius, text.chars.length ].min
-
-          prefix  = start_pos > 0 ? excerpt_string : ""
-          postfix = end_pos < text.chars.length ? excerpt_string : ""
-
-          prefix + text.chars[start_pos..end_pos].strip + postfix
-        else
-          nil
-        end
-      end
-
-      # Attempts to pluralize the +singular+ word unless +count+ is 1. If +plural+
-      # is supplied, it will use that when count is > 1, if the ActiveSupport Inflector 
-      # is loaded, it will use the Inflector to determine the plural form, otherwise 
-      # it will just add an 's' to the +singular+ word.
-      #
-      #   pluralize(1, 'person')  => 1 person
-      #   pluralize(2, 'person')  => 2 people
-      #   pluralize(3, 'person', 'users')  => 3 users
-      def pluralize(count, singular, plural = nil)
-         "#{count} " + if count == 1 || count == '1'
-          singular
-        elsif plural
-          plural
-        elsif Object.const_defined?("Inflector")
-          Inflector.pluralize(singular)
-        else
-          singular + "s"
-        end
-      end
-
-      # Wraps the +text+ into lines no longer than +line_width+ width. This method
-      # breaks on the first whitespace character that does not exceed +line_width+.
-      #
-      #   word_wrap('Once upon a time', 4)
-      #    => Once\nupon\na\ntime
-      def word_wrap(text, line_width = 80)
-        text.gsub(/\n/, "\n\n").gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip
-      end
-
-      begin
-        require_library_or_gem "redcloth" unless Object.const_defined?(:RedCloth)
-
-        # Returns the text with all the Textile codes turned into HTML tags.
-        # <i>This method is only available if RedCloth[http://whytheluckystiff.net/ruby/redcloth/]
-        # is available</i>.
-        def textilize(text)
-          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 bounding <p> tag that RedCloth adds.
-        # <i>This method is only available if RedCloth[http://whytheluckystiff.net/ruby/redcloth/]
-        # is available</i>.
-        def textilize_without_paragraph(text)
-          textiled = textilize(text)
-          if textiled[0..2] == "<p>" then textiled = textiled[3..-1] end
-          if textiled[-4..-1] == "</p>" then textiled = textiled[0..-5] end
-          return textiled
-        end
-      rescue LoadError
-        # We can't really help what's not there
-      end
-
-      begin
-        require_library_or_gem "bluecloth" unless Object.const_defined?(:BlueCloth)
-
-        # Returns the text with all the Markdown codes turned into HTML tags.
-        # <i>This method is only available if BlueCloth[http://www.deveiate.org/projects/BlueCloth]
-        # is available</i>.
-        def markdown(text)
-          text.blank? ? "" : BlueCloth.new(text).to_html
-        end
-      rescue LoadError
-        # We can't really help what's not there
-      end
-      
-      # Returns +text+ transformed into HTML using simple formatting rules.
-      # Two or more consecutive newlines(<tt>\n\n</tt>) are considered as a 
-      # paragraph and wrapped in <tt><p></tt> tags. One newline (<tt>\n</tt>) is
-      # considered as a linebreak and a <tt><br /></tt> tag is appended. This
-      # method does not remove the newlines from the +text+. 
-      def simple_format(text)
-        content_tag 'p', text.to_s.
-          gsub(/\r\n?/, "\n").                    # \r\n and \r -> \n
-          gsub(/\n\n+/, "</p>\n\n<p>").           # 2+ newline  -> paragraph
-          gsub(/([^\n]\n)(?=[^\n])/, '\1<br />')  # 1 newline   -> br
-      end
-
-      # Turns all urls and email addresses into clickable links. The +link+ parameter 
-      # will limit what should be linked. You can add html attributes to the links using
-      # +href_options+. Options for +link+ are <tt>:all</tt> (default), 
-      # <tt>:email_addresses</tt>, and <tt>:urls</tt>.
-      #
-      #   auto_link("Go to http://www.rubyonrails.org and say hello to david@loudthinking.com") =>
-      #     Go to <a href="http://www.rubyonrails.org">http://www.rubyonrails.org</a> and
-      #     say hello to <a href="mailto:david@loudthinking.com">david@loudthinking.com</a>
-      #
-      # If a block is given, each url and email address is yielded and the
-      # result is used as the link text.
-      #
-      #   auto_link(post.body, :all, :target => '_blank') do |text|
-      #     truncate(text, 15)
-      #   end
-      def auto_link(text, link = :all, href_options = {}, &block)
-        return '' if text.blank?
-        case link
-          when :all             then auto_link_urls(auto_link_email_addresses(text, &block), href_options, &block)
-          when :email_addresses then auto_link_email_addresses(text, &block)
-          when :urls            then auto_link_urls(text, href_options, &block)
-        end
-      end
-
-      # Strips link tags from +text+ leaving just the link label.
-      #
-      #   strip_links('<a href="http://www.rubyonrails.org">Ruby on Rails</a>')
-      #    => Ruby on Rails
-      def strip_links(text)
-        text.gsub(/<a\b.*?>(.*?)<\/a>/mi, '\1')
-      end
-
-      # Try to require the html-scanner library
-      begin
-        require 'html/tokenizer'
-        require 'html/node'
-      rescue LoadError
-        # if there isn't a copy installed, use the vendor version in
-        # ActionController
-        $:.unshift File.join(File.dirname(__FILE__), "..", "..",
-                      "action_controller", "vendor", "html-scanner")
-        require 'html/tokenizer'
-        require 'html/node'
-      end
-
-      VERBOTEN_TAGS = %w(form script plaintext) unless defined?(VERBOTEN_TAGS)
-      VERBOTEN_ATTRS = /^on/i unless defined?(VERBOTEN_ATTRS)
-
-      # Sanitizes the +html+ by converting <form> and <script> tags into regular
-      # text, and removing all "onxxx" attributes (so that arbitrary Javascript
-      # cannot be executed). It also removes href= and src= attributes that start with
-      # "javascript:". You can modify what gets sanitized by defining VERBOTEN_TAGS
-      # and VERBOTEN_ATTRS before this Module is loaded.
-      #
-      #   sanitize('<script> do_nasty_stuff() </script>')
-      #    => &lt;script> do_nasty_stuff() &lt;/script>
-      #   sanitize('<a href="javascript: sucker();">Click here for $100</a>')
-      #    => <a>Click here for $100</a>
-      def sanitize(html)
-        # only do this if absolutely necessary
-        if html.index("<")
-          tokenizer = HTML::Tokenizer.new(html)
-          new_text = ""
-
-          while token = tokenizer.next
-            node = HTML::Node.parse(nil, 0, 0, token, false)
-            new_text << case node
-              when HTML::Tag
-                if VERBOTEN_TAGS.include?(node.name)
-                  node.to_s.gsub(/</, "&lt;")
-                else
-                  if node.closing != :close
-                    node.attributes.delete_if { |attr,v| attr =~ VERBOTEN_ATTRS }
-                    %w(href src).each do |attr|
-                      node.attributes.delete attr if node.attributes[attr] =~ /^javascript:/i
-                    end
-                  end
-                  node.to_s
-                end
-              else
-                node.to_s.gsub(/</, "&lt;")
-            end
-          end
-
-          html = new_text
-        end
-
-        html
-      end
-      
-      # Strips all HTML tags from the +html+, including comments.  This uses the 
-      # html-scanner tokenizer and so its HTML parsing ability is limited by 
-      # that of html-scanner.
-      def strip_tags(html)     
-        return html if html.blank?
-        if html.index("<")
-          text = ""
-          tokenizer = HTML::Tokenizer.new(html)
-
-          while token = tokenizer.next
-            node = HTML::Node.parse(nil, 0, 0, token, false)
-            # result is only the content of any Text nodes
-            text << node.to_s if node.class == HTML::Text  
-          end
-          # strip any comments, and if they have a newline at the end (ie. line with
-          # only a comment) strip that too
-          text.gsub(/<!--(.*?)-->[\n]?/m, "") 
-        else
-          html # already plain text
-        end 
-      end
-      
-      # Creates a Cycle object whose _to_s_ method cycles through elements of an
-      # array every time it is called. This can be used for example, to alternate 
-      # classes for table rows:
-      #
-      #   <% @items.each do |item| %>
-      #     <tr class="<%= cycle("even", "odd") -%>">
-      #       <td>item</td>
-      #     </tr>
-      #   <% end %>
-      #
-      # You can use named cycles to allow nesting in loops.  Passing a Hash as 
-      # the last parameter with a <tt>:name</tt> key will create a named cycle.
-      # You can manually reset a cycle by calling reset_cycle and passing the 
-      # name of the cycle.
-      #
-      #   <% @items.each do |item| %>
-      #     <tr class="<%= cycle("even", "odd", :name => "row_class")
-      #       <td>
-      #         <% item.values.each do |value| %>
-      #           <span style="color:<%= cycle("red", "green", "blue", :name => "colors") -%>">
-      #             value
-      #           </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 the next time 
-      # it is called. Pass in +name+ to reset a named cycle.
-      def reset_cycle(name = "default")
-        cycle = get_cycle(name)
-        cycle.reset unless cycle.nil?
-      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
-        # 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 unless defined?(@_cycles)
-          return @_cycles[name]
-        end
-        
-        def set_cycle(name, cycle_object)
-          @_cycles = Hash.new unless defined?(@_cycles)
-          @_cycles[name] = cycle_object
-        end
-
-        AUTO_LINK_RE = %r{
-                        (                          # leading text
-                          <\w+.*?>|                # leading HTML tag, or
-                          [^=!:'"/]|               # leading punctuation, or 
-                          ^                        # beginning of line
-                        )
-                        (
-                          (?:https?://)|           # protocol spec, or
-                          (?:www\.)                # www.*
-                        ) 
-                        (
-                          [-\w]+                   # subdomain or domain
-                          (?:\.[-\w]+)*            # remaining subdomains or domain
-                          (?::\d+)?                # port
-                          (?:/(?:(?:[~\w\+%-]|(?:[,.;:][^\s$]))+)?)* # path
-                          (?:\?[\w\+%&=.;-]+)?     # query string
-                          (?:\#[\w\-]*)?           # trailing anchor
-                        )
-                        ([[:punct:]]|\s|<|$)       # trailing text
-                       }x unless const_defined?(:AUTO_LINK_RE)
-
-        # Turns all urls into clickable links.  If a block is given, each url
-        # is yielded and the result is used as the link text.
-        def auto_link_urls(text, href_options = {})
-          extra_options = tag_options(href_options.stringify_keys) || ""
-          text.gsub(AUTO_LINK_RE) do
-            all, a, b, c, d = $&, $1, $2, $3, $4
-            if a =~ /<a\s/i # don't replace URL's that are already linked
-              all
-            else
-              text = b + c
-              text = yield(text) if block_given?
-              %(#{a}<a href="#{b=="www."?"http://www.":b}#{c}"#{extra_options}>#{text}</a>#{d})
-            end
-          end
-        end
-
-        # Turns all email addresses into clickable links.  If a block is given,
-        # each email is yielded and the result is used as the link text.
-        def auto_link_email_addresses(text)
-          text.gsub(/([\w\.!#\$%\-+.]+@[A-Za-z0-9\-]+(\.[A-Za-z0-9\-]+)+)/) do
-            text = $1
-            text = yield(text) if block_given?
-            %{<a href="mailto:#{$1}">#{text}</a>}
-          end
-        end
-    end
-  end
-end