radiant 0.5.2 → 0.6.0

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

@@ -0,0 +1,70 @@
+
+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/vendor/rails/actionpack/lib/action_view/helpers/active_record_helper.rb

@@ -0,0 +1,237 @@
+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/vendor/rails/actionpack/lib/action_view/helpers/asset_tag_helper.rb

@@ -0,0 +1,218 @@
+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