rq 3.4.0 → 3.5.0

data/rails/vendor/rails/actionpack/lib/action_view/compiled_templates.rb

@@ -1,70 +0,0 @@
-
-module ActionView
-
-  # CompiledTemplates modules hold methods that have been compiled.
-  # Templates are compiled into these methods so that they do not need to be
-  # re-read and re-parsed each request.
-  #
-  # Each template may be compiled into one or more methods. Each method accepts a given
-  # set of parameters which is used to implement local assigns passing.
-  #
-  # To use a compiled template module, create a new instance and include it into the class
-  # in which you want the template to be rendered.
-  class CompiledTemplates < Module #:nodoc:
-    attr_reader :method_names
-
-    def initialize
-      @method_names = Hash.new do |hash, key|
-        hash[key] = "__compiled_method_#{(hash.length + 1)}"
-      end
-      @mtimes = {}
-    end
-    
-    # Return the full key for the given identifier and argument names
-    def full_key(identifier, arg_names)
-      [identifier, arg_names]
-    end
-
-    # Return the selector for this method or nil if it has not been compiled
-    def selector(identifier, arg_names)
-      key = full_key(identifier, arg_names)
-      method_names.key?(key) ? method_names[key] : nil
-    end
-    alias :compiled? :selector
-
-    # Return the time at which the method for the given identifier and argument names was compiled.
-    def mtime(identifier, arg_names)
-      @mtimes[full_key(identifier, arg_names)]
-    end
-    
-    # Compile the provided source code for the given argument names and with the given initial line number.
-    # The identifier should be unique to this source.
-    #
-    # The file_name, if provided will appear in backtraces. If not provded, the file_name defaults
-    # to the identifier.
-    #
-    # This method will return the selector for the compiled version of this method.
-    def compile_source(identifier, arg_names, source, initial_line_number = 0, file_name = nil)
-      file_name ||= identifier
-      name = method_names[full_key(identifier, arg_names)]
-      arg_desc = arg_names.empty? ? '' : "(#{arg_names * ', '})"
-      fake_file_name = "#{file_name}#{arg_desc}" # Include the arguments for this version (for now)
-      
-      method_def = wrap_source(name, arg_names, source)
-      
-      begin
-        module_eval(method_def, fake_file_name, initial_line_number)
-        @mtimes[full_key(identifier, arg_names)] = Time.now
-      rescue Exception => e  # errors from compiled source
-        e.blame_file! identifier
-        raise
-      end
-      name
-    end
-    
-    # Wrap the provided source in a def ... end block.
-    def wrap_source(name, arg_names, source)
-      "def #{name}(#{arg_names * ', '})\n#{source}\nend"
-    end
-  end
-end

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

@@ -1,237 +0,0 @@
-require 'cgi'
-require File.dirname(__FILE__) + '/form_helper'
-
-module ActionView
-  class Base
-    @@field_error_proc = Proc.new{ |html_tag, instance| "<div class=\"fieldWithErrors\">#{html_tag}</div>" }
-    cattr_accessor :field_error_proc
-  end
-
-  module Helpers
-    # The Active Record Helper makes it easier to create forms for records kept in instance variables. The most far-reaching is the form
-    # method that creates a complete form for all the basic content types of the record (not associations or aggregations, though). This
-    # is a great of making the record quickly available for editing, but likely to prove lackluster for a complicated real-world form.
-    # In that case, it's better to use the input method and the specialized form methods in link:classes/ActionView/Helpers/FormHelper.html
-    module ActiveRecordHelper
-      # Returns a default input tag for the type of object returned by the method. Example
-      # (title is a VARCHAR column and holds "Hello World"):
-      #   input("post", "title") =>
-      #     <input id="post_title" name="post[title]" size="30" type="text" value="Hello World" />
-      def input(record_name, method, options = {})
-        InstanceTag.new(record_name, method, self).to_tag(options)
-      end
-
-      # Returns an entire form with input tags and everything for a specified Active Record object. Example
-      # (post is a new record that has a title using VARCHAR and a body using TEXT):
-      #   form("post") =>
-      #     <form action='/post/create' method='post'>
-      #       <p>
-      #         <label for="post_title">Title</label><br />
-      #         <input id="post_title" name="post[title]" size="30" type="text" value="Hello World" />
-      #       </p>
-      #       <p>
-      #         <label for="post_body">Body</label><br />
-      #         <textarea cols="40" id="post_body" name="post[body]" rows="20">
-      #           Back to the hill and over it again!
-      #         </textarea>
-      #       </p>
-      #       <input type='submit' value='Create' />
-      #     </form>
-      #
-      # It's possible to specialize the form builder by using a different action name and by supplying another
-      # block renderer. Example (entry is a new record that has a message attribute using VARCHAR):
-      #
-      #   form("entry", :action => "sign", :input_block =>
-      #        Proc.new { |record, column| "#{column.human_name}: #{input(record, column.name)}<br />" }) =>
-      #
-      #     <form action='/post/sign' method='post'>
-      #       Message:
-      #       <input id="post_title" name="post[title]" size="30" type="text" value="Hello World" /><br />
-      #       <input type='submit' value='Sign' />
-      #     </form>
-      #
-      # It's also possible to add additional content to the form by giving it a block, such as:
-      #
-      #   form("entry", :action => "sign") do |form|
-      #     form << content_tag("b", "Department")
-      #     form << collection_select("department", "id", @departments, "id", "name")
-      #   end
-      def form(record_name, options = {})
-        record = instance_variable_get("@#{record_name}")
-
-        options = options.symbolize_keys
-        options[:action] ||= record.new_record? ? "create" : "update"
-        action = url_for(:action => options[:action], :id => record)
-
-        submit_value = options[:submit_value] || options[:action].gsub(/[^\w]/, '').capitalize
-
-        contents = ''
-        contents << hidden_field(record_name, :id) unless record.new_record?
-        contents << all_input_tags(record, record_name, options)
-        yield contents if block_given?
-        contents << submit_tag(submit_value)
-
-        content_tag('form', contents, :action => action, :method => 'post', :enctype => options[:multipart] ? 'multipart/form-data': nil)
-      end
-
-      # Returns a string containing the error message attached to the +method+ on the +object+, if one exists.
-      # This error message is wrapped in a DIV tag, which can be specialized to include both a +prepend_text+ and +append_text+
-      # to properly introduce the error and a +css_class+ to style it accordingly. Examples (post has an error message
-      # "can't be empty" on the title attribute):
-      #
-      #   <%= error_message_on "post", "title" %> =>
-      #     <div class="formError">can't be empty</div>
-      #
-      #   <%= error_message_on "post", "title", "Title simply ", " (or it won't work)", "inputError" %> =>
-      #     <div class="inputError">Title simply can't be empty (or it won't work)</div>
-      def error_message_on(object, method, prepend_text = "", append_text = "", css_class = "formError")
-        if (obj = instance_variable_get("@#{object}")) && (errors = obj.errors.on(method))
-          content_tag("div", "#{prepend_text}#{errors.is_a?(Array) ? errors.first : errors}#{append_text}", :class => css_class)
-        else 
-          ''
-        end
-      end
-
-      # Returns a string with a div containing all of the error messages for the objects located as instance variables by the names
-      # given.  If more than one object is specified, the errors for the objects are displayed in the order that the object names are
-      # provided.
-      #
-      # This div can be tailored by the following options:
-      #
-      # * <tt>header_tag</tt> - Used for the header of the error div (default: h2)
-      # * <tt>id</tt> - The id of the error div (default: errorExplanation)
-      # * <tt>class</tt> - The class of the error div (default: errorExplanation)
-      # * <tt>object_name</tt> - The object name to use in the header, or
-      # any text that you prefer. If <tt>object_name</tt> is not set, the name of
-      # the first object will be used.
-      #
-      # Specifying one object:
-      # 
-      #   error_messages_for 'user'
-      #
-      # Specifying more than one object (and using the name 'user' in the
-      # header as the <tt>object_name</tt> instead of 'user_common'):
-      #
-      #   error_messages_for 'user_common', 'user', :object_name => 'user'
-      #
-      # NOTE: This is a pre-packaged presentation of the errors with embedded strings and a certain HTML structure. If what
-      # you need is significantly different from the default presentation, it makes plenty of sense to access the object.errors
-      # instance yourself and set it up. View the source of this method to see how easy it is.
-      def error_messages_for(*params)
-        options = params.last.is_a?(Hash) ? params.pop.symbolize_keys : {}
-        objects = params.collect {|object_name| instance_variable_get("@#{object_name}") }.compact
-        count   = objects.inject(0) {|sum, object| sum + object.errors.count }
-        unless count.zero?
-          html = {}
-          [:id, :class].each do |key|
-            if options.include?(key)
-              value = options[key]
-              html[key] = value unless value.blank?
-            else
-              html[key] = 'errorExplanation'
-            end
-          end
-          header_message = "#{pluralize(count, 'error')} prohibited this #{(options[:object_name] || params.first).to_s.gsub('_', ' ')} from being saved"
-          error_messages = objects.map {|object| object.errors.full_messages.map {|msg| content_tag(:li, msg) } }
-          content_tag(:div,
-            content_tag(options[:header_tag] || :h2, header_message) <<
-              content_tag(:p, 'There were problems with the following fields:') <<
-              content_tag(:ul, error_messages),
-            html
-          )
-        else
-          ''
-        end
-      end
-
-      private
-        def all_input_tags(record, record_name, options)
-          input_block = options[:input_block] || default_input_block
-          record.class.content_columns.collect{ |column| input_block.call(record_name, column) }.join("\n")
-        end
-
-        def default_input_block
-          Proc.new { |record, column| %(<p><label for="#{record}_#{column.name}">#{column.human_name}</label><br />#{input(record, column.name)}</p>) }
-        end
-    end
-
-    class InstanceTag #:nodoc:
-      def to_tag(options = {})
-        case column_type
-          when :string
-            field_type = @method_name.include?("password") ? "password" : "text"
-            to_input_field_tag(field_type, options)
-          when :text
-            to_text_area_tag(options)
-          when :integer, :float, :decimal
-            to_input_field_tag("text", options)
-          when :date
-            to_date_select_tag(options)
-          when :datetime, :timestamp
-            to_datetime_select_tag(options)
-          when :time
-            to_time_select_tag(options)
-          when :boolean
-            to_boolean_select_tag(options)
-        end
-      end
-
-      alias_method :tag_without_error_wrapping, :tag
-      def tag(name, options)
-        if object.respond_to?("errors") && object.errors.respond_to?("on")
-          error_wrapping(tag_without_error_wrapping(name, options), object.errors.on(@method_name))
-        else
-          tag_without_error_wrapping(name, options)
-        end
-      end
-
-      alias_method :content_tag_without_error_wrapping, :content_tag
-      def content_tag(name, value, options)
-        if object.respond_to?("errors") && object.errors.respond_to?("on")
-          error_wrapping(content_tag_without_error_wrapping(name, value, options), object.errors.on(@method_name))
-        else
-          content_tag_without_error_wrapping(name, value, options)
-        end
-      end
-
-      alias_method :to_date_select_tag_without_error_wrapping, :to_date_select_tag
-      def to_date_select_tag(options = {})
-        if object.respond_to?("errors") && object.errors.respond_to?("on")
-          error_wrapping(to_date_select_tag_without_error_wrapping(options), object.errors.on(@method_name))
-        else
-          to_date_select_tag_without_error_wrapping(options)
-        end
-      end
-
-      alias_method :to_datetime_select_tag_without_error_wrapping, :to_datetime_select_tag
-      def to_datetime_select_tag(options = {})
-        if object.respond_to?("errors") && object.errors.respond_to?("on")
-            error_wrapping(to_datetime_select_tag_without_error_wrapping(options), object.errors.on(@method_name))
-          else
-            to_datetime_select_tag_without_error_wrapping(options)
-        end
-      end
-
-      alias_method :to_time_select_tag_without_error_wrapping, :to_time_select_tag
-      def to_time_select_tag(options = {})
-        if object.respond_to?("errors") && object.errors.respond_to?("on")
-          error_wrapping(to_time_select_tag_without_error_wrapping(options), object.errors.on(@method_name))
-        else
-          to_time_select_tag_without_error_wrapping(options)
-        end
-      end
-
-      def error_wrapping(html_tag, has_error)
-        has_error ? Base.field_error_proc.call(html_tag, self) : html_tag
-      end
-
-      def error_message
-        object.errors.on(@method_name)
-      end
-
-      def column_type
-        object.send("column_for_attribute", @method_name).type
-      end
-    end
-  end
-end

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

@@ -1,218 +0,0 @@
-require 'cgi'
-require File.dirname(__FILE__) + '/url_helper'
-require File.dirname(__FILE__) + '/tag_helper'
-
-module ActionView
-  module Helpers #:nodoc:
-    # Provides methods for linking an HTML page together with other assets such
-    # as images, javascripts, stylesheets, and feeds. You can direct Rails to
-    # link to assets from a dedicated assets server by setting ActionController::Base.asset_host
-    # in your environment.rb. These methods do not verify the assets exist before
-    # linking to them.
-    #
-    #   ActionController::Base.asset_host = "http://assets.example.com"
-    #   image_tag("rails.png")  
-    #     => <img src="http://assets.example.com/images/rails.png" alt="Rails" />
-    #   stylesheet_include_tag("application")
-    #     => <link href="http://assets.example.com/stylesheets/application.css" media="screen" rel="Stylesheet" type="text/css" />
-    module AssetTagHelper
-      # Returns a link tag that browsers and news readers can use to auto-detect
-      # an RSS or ATOM feed. The +type+ can either be <tt>:rss</tt> (default) or 
-      # <tt>:atom</tt>. Control the link options in url_for format using the
-      # +url_options+. You can modify the LINK tag itself in +tag_options+.
-      #
-      # Tag Options:
-      # * <tt>:rel</tt>  - Specify the relation of this link, defaults to "alternate"
-      # * <tt>:type</tt>  - Override the auto-generated mime type
-      # * <tt>:title</tt>  - Specify the title of the link, defaults to the +type+
-      #
-      #  auto_discovery_link_tag # =>
-      #     <link rel="alternate" type="application/rss+xml" title="RSS" href="http://www.curenthost.com/controller/action" />
-      #  auto_discovery_link_tag(:atom) # =>
-      #     <link rel="alternate" type="application/atom+xml" title="ATOM" href="http://www.curenthost.com/controller/action" />
-      #  auto_discovery_link_tag(:rss, {:action => "feed"}) # =>
-      #     <link rel="alternate" type="application/rss+xml" title="RSS" href="http://www.curenthost.com/controller/feed" />
-      #  auto_discovery_link_tag(:rss, {:action => "feed"}, {:title => "My RSS"}) # =>
-      #     <link rel="alternate" type="application/rss+xml" title="My RSS" href="http://www.curenthost.com/controller/feed" />
-      def auto_discovery_link_tag(type = :rss, url_options = {}, tag_options = {})
-        tag(
-          "link", 
-          "rel"   => tag_options[:rel] || "alternate",
-          "type"  => tag_options[:type] || "application/#{type}+xml",
-          "title" => tag_options[:title] || type.to_s.upcase,
-          "href"  => url_options.is_a?(Hash) ? url_for(url_options.merge(:only_path => false)) : url_options
-        )
-      end
-
-      # Computes the path to a javascript asset in the public javascripts directory.
-      # If the +source+ filename has no extension, .js will be appended.
-      # Full paths from the document root will be passed through.
-      # Used internally by javascript_include_tag to build the script path.
-      #
-      #   javascript_path "xmlhr" # => /javascripts/xmlhr.js
-      #   javascript_path "dir/xmlhr.js" # => /javascripts/dir/xmlhr.js
-      #   javascript_path "/dir/xmlhr" # => /dir/xmlhr.js
-      def javascript_path(source)
-        compute_public_path(source, 'javascripts', 'js')        
-      end
-
-      JAVASCRIPT_DEFAULT_SOURCES = ['prototype', 'effects', 'dragdrop', 'controls'] unless const_defined?(:JAVASCRIPT_DEFAULT_SOURCES)
-      @@javascript_default_sources = JAVASCRIPT_DEFAULT_SOURCES.dup
-
-      # Returns an html script tag for each of the +sources+ provided. You
-      # can pass in the filename (.js extension is optional) of javascript files
-      # that exist in your public/javascripts directory for inclusion into the
-      # current page or you can pass the full path relative to your document
-      # root. To include the Prototype and Scriptaculous javascript libraries in
-      # your application, pass <tt>:defaults</tt> as the source. When using 
-      # :defaults, if an <tt>application.js</tt> file exists in your public 
-      # javascripts directory, it will be included as well. You can modify the 
-      # html attributes of the script tag by passing a hash as the last argument. 
-      #
-      #   javascript_include_tag "xmlhr" # =>
-      #     <script type="text/javascript" src="/javascripts/xmlhr.js"></script>
-      #
-      #   javascript_include_tag "common.javascript", "/elsewhere/cools" # =>
-      #     <script type="text/javascript" src="/javascripts/common.javascript"></script>
-      #     <script type="text/javascript" src="/elsewhere/cools.js"></script>
-      #
-      #   javascript_include_tag :defaults # =>
-      #     <script type="text/javascript" src="/javascripts/prototype.js"></script>
-      #     <script type="text/javascript" src="/javascripts/effects.js"></script>
-      #     ...
-      #     <script type="text/javascript" src="/javascripts/application.js"></script> *see below
-      def javascript_include_tag(*sources)
-        options = sources.last.is_a?(Hash) ? sources.pop.stringify_keys : { }
-
-        if sources.include?(:defaults) 
-          sources = sources[0..(sources.index(:defaults))] + 
-            @@javascript_default_sources.dup + 
-            sources[(sources.index(:defaults) + 1)..sources.length]
-
-          sources.delete(:defaults) 
-          sources << "application" if defined?(RAILS_ROOT) && File.exists?("#{RAILS_ROOT}/public/javascripts/application.js") 
-        end
-
-        sources.collect do |source|
-          source = javascript_path(source)        
-          content_tag("script", "", { "type" => "text/javascript", "src" => source }.merge(options))
-        end.join("\n")
-      end
-      
-      # Register one or more additional JavaScript files to be included when
-      # <tt>javascript_include_tag :defaults</tt> is called. This method is
-      # only intended to be called from plugin initialization to register additional 
-      # .js files that the plugin installed in <tt>public/javascripts</tt>.
-      def self.register_javascript_include_default(*sources)
-        @@javascript_default_sources.concat(sources)
-      end
-      
-      def self.reset_javascript_include_default #:nodoc:
-        @@javascript_default_sources = JAVASCRIPT_DEFAULT_SOURCES.dup
-      end
-
-      # Computes the path to a stylesheet asset in the public stylesheets directory.
-      # If the +source+ filename has no extension, .css will be appended.
-      # Full paths from the document root will be passed through.
-      # Used internally by stylesheet_link_tag to build the stylesheet path.
-      #
-      #   stylesheet_path "style" # => /stylesheets/style.css
-      #   stylesheet_path "dir/style.css" # => /stylesheets/dir/style.css
-      #   stylesheet_path "/dir/style.css" # => /dir/style.css
-      def stylesheet_path(source)
-        compute_public_path(source, 'stylesheets', 'css')
-      end
-
-      # Returns a stylesheet link tag for the sources specified as arguments. If
-      # you don't specify an extension, .css will be appended automatically.
-      # You can modify the link attributes by passing a hash as the last argument.
-      #
-      #   stylesheet_link_tag "style" # =>
-      #     <link href="/stylesheets/style.css" media="screen" rel="Stylesheet" type="text/css" />
-      #
-      #   stylesheet_link_tag "style", :media => "all" # =>
-      #     <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css" />
-      #
-      #   stylesheet_link_tag "random.styles", "/css/stylish" # =>
-      #     <link href="/stylesheets/random.styles" media="screen" rel="Stylesheet" type="text/css" />
-      #     <link href="/css/stylish.css" media="screen" rel="Stylesheet" type="text/css" />
-      def stylesheet_link_tag(*sources)
-        options = sources.last.is_a?(Hash) ? sources.pop.stringify_keys : { }
-        sources.collect do |source|
-          source = stylesheet_path(source)
-          tag("link", { "rel" => "Stylesheet", "type" => "text/css", "media" => "screen", "href" => source }.merge(options))
-        end.join("\n")
-      end
-
-      # Computes the path to an image asset in the public images directory.
-      # Full paths from the document root will be passed through.
-      # Used internally by image_tag to build the image path. Passing
-      # a filename without an extension is deprecated.
-      #
-      #   image_path("edit.png")  # => /images/edit.png
-      #   image_path("icons/edit.png")  # => /images/icons/edit.png
-      #   image_path("/icons/edit.png")  # => /icons/edit.png
-      def image_path(source)
-        unless (source.split("/").last || source).include?(".") || source.blank?
-          ActiveSupport::Deprecation.warn(
-            "You've called image_path with a source that doesn't include an extension. " +
-            "In Rails 2.0, that will not result in .png automatically being appended. " +
-            "So you should call image_path('#{source}.png') instead", caller
-          )
-        end
-
-        compute_public_path(source, 'images', 'png')
-      end
-
-      # Returns an html image tag for the +source+. The +source+ can be a full
-      # path or a file that exists in your public images directory. Note that 
-      # specifying a filename without the extension is now deprecated in Rails.
-      # You can add html attributes using the +options+. The +options+ supports
-      # two additional keys for convienence and conformance:
-      #
-      # * <tt>:alt</tt>  - If no alt text is given, the file name part of the 
-      #   +source+ is used (capitalized and without the extension)
-      # * <tt>:size</tt> - Supplied as "{Width}x{Height}", so "30x45" becomes 
-      #   width="30" and height="45". <tt>:size</tt> will be ignored if the
-      #   value is not in the correct format.
-      #
-      #  image_tag("icon.png")  # =>
-      #    <img src="/images/icon.png" alt="Icon" />
-      #  image_tag("icon.png", :size => "16x10", :alt => "Edit Entry")  # =>
-      #    <img src="/images/icon.png" width="16" height="10" alt="Edit Entry" />
-      #  image_tag("/icons/icon.gif", :size => "16x16")  # =>
-      #    <img src="/icons/icon.gif" width="16" height="16" alt="Icon" />
-      def image_tag(source, options = {})
-        options.symbolize_keys!
-                
-        options[:src] = image_path(source)
-        options[:alt] ||= File.basename(options[:src], '.*').split('.').first.capitalize
-        
-        if options[:size]
-          options[:width], options[:height] = options[:size].split("x") if options[:size] =~ %r{^\d+x\d+$}
-          options.delete(:size)
-        end
-
-        tag("img", options)
-      end
-      
-      private
-        def compute_public_path(source, dir, ext)
-          source = source.dup
-          source << ".#{ext}" if File.extname(source).blank?
-          unless source =~ %r{^[-a-z]+://}
-            source = "/#{dir}/#{source}" unless source[0] == ?/
-            asset_id = rails_asset_id(source)
-            source << '?' + asset_id if defined?(RAILS_ROOT) && !asset_id.blank?
-            source = "#{ActionController::Base.asset_host}#{@controller.request.relative_url_root}#{source}"
-          end
-          source
-        end
-        
-        def rails_asset_id(source)
-          ENV["RAILS_ASSET_ID"] || 
-            File.mtime("#{RAILS_ROOT}/public/#{source}").to_i.to_s rescue ""
-        end
-    end
-  end
-end