class ActionView::Base

More builder documentation can be found at builder.rubyforge.org.
end
end
end
end
xml.tag!(“dc:creator”, item.author_name) if item_has_creator?(item)
xml.link(@person.firm.account.url + @recent_items.url(item))
xml.guid(@person.firm.account.url + @recent_items.url(item))
xml.pubDate(item_pubDate(item))
xml.description(item_description(item)) if item_description(item)
xml.title(item_title(item))
xml.item do
@recent_items.each do |item|
xml.ttl “40”
xml.language “en-us”
xml.description “Basecamp: Recent items”
xml.link(@url)
xml.title(@feed_title)
xml.channel do
xml.rss(“version” => “2.0”, “xmlns:dc” => “purl.org/dc/elements/1.1/”) do
A full-length RSS example actually used on Basecamp:
</div>
<p>A product of Danish Design during the Winter of ‘79…</p>
<h1>David Heinemeier Hansson</h1>
<div>
would produce something like:
end
xml.p(@person.bio)
xml.h1(@person.name)
xml.div do
Any method with a block will be treated as an XML markup tag with nested markup in the block. For example, the following:
# NOTE: order of attributes is not specified.
xml.target(“name” => “compile”, “option” => “fast”) # => <target option=“fast” name=“compile”>
xml.a(“A Link”, “href” => “onestepback.org”) # => <a href=“onestepback.org”>A Link</a>
xml.em { xml.b(“emph & bold”) } # => emph &amp; bold
xml.em(“emphasized”) # => emphasized
Here are some basic examples:
named xml is automatically made available to templates with a .builder extension.
Builder templates are a more programmatic alternative to ERB. They are especially useful for generating XML content. An XmlMarkup object
== Builder
Rails will check the file’s modification time and recompile it in development mode.
By default, Rails will compile each template to a method in order to render it. When you alter a template,
=== Template caching
Testing using defined? headline will not work. This is an implementation restriction.
<% end %>
Headline: <%= headline %>
<% if local_assigns.has_key? :headline %>
you need to use the following pattern:
If you need to find out whether a certain local variable has been assigned a value in a particular render call,
First name: <%= person.first_name %>
Headline: <%= headline %>
These can now be accessed in shared/header with:
<%= render “shared/header”, { headline: “Welcome”, person: person } %>
You can pass local variables to sub templates by using a hash with the variable names as keys and the objects as values:
=== Passing local variables to sub templates
<title><%= @page_title %></title>
Now the header can pick up on the @page_title variable and use it for outputting a title tag:
<%= render “shared/header” %>
<% @page_title = “A Wonderful Hello” %>
variables defined using the regular embedding tags. Like this:
But you don’t have to restrict yourself to static includes. Templates can share variables amongst themselves by using instance
result of the rendering. The output embedding writes it to the current template.
As you see, we use the output embeddings for the render methods. The render call itself will just return a string holding the
<%= render “shared/footer” %>
Something really specific and terrific
<%= render “shared/header” %>
classic example is the use of a header and footer (even though the Action Pack-way would be to use Layouts):
Using sub templates allows you to sidestep tedious replication and extract common display structures in shared templates. The
=== Using sub templates
<%- and -%> suppress leading and trailing whitespace, including the trailing newline, and can be used interchangeably with <% and %>.
If you absolutely must write from within a function use concat.
Hi, Mr. <% puts “Frodo” %>
<%# WRONG %>
is not just a usage suggestion. Regular output functions like print or puts won’t work with ERB templates. So this would be wrong:
The loop is setup in regular embedding tags <% %> and the name is written using the output embedding tag <%= %>. Note that this
<% end %>
Name: <%= person.name %><br/>
<% @people.each do |person| %>
Names of all the people
following loop for names:
You trigger ERB by using embeddings such as <% %>, <% -%>, and <%= %>. The <%= %> tag set is used when you want output. Consider the
== ERB
(included in Ruby) and HTML. If the template file has a .builder extension then Jim Weirich’s Builder::XmlMarkup library is used.
Action View templates can be written in several ways. If the template file has a .erb extension then it uses a mixture of ERB
= Action View Base
:nodoc:

def assign(new_assigns) # :nodoc:

:nodoc: 
def assign(new_assigns) # :nodoc:
  @_assigns = new_assigns.each { |key, value| instance_variable_set("@#{key}", value) }
end

def cache_template_loading 

def cache_template_loading
  ActionView::Resolver.caching?
end

def cache_template_loading=(value) 

def cache_template_loading=(value)
  ActionView::Resolver.caching = value
end

def initialize(context = nil, assigns = {}, controller = nil, formats = nil) #:nodoc:

:nodoc: 
def initialize(context = nil, assigns = {}, controller = nil, formats = nil) #:nodoc:
  @_config = ActiveSupport::InheritableOptions.new
  if context.is_a?(ActionView::Renderer)
    @view_renderer = context
  else
    lookup_context = context.is_a?(ActionView::LookupContext) ?
      context : ActionView::LookupContext.new(context)
    lookup_context.formats  = formats if formats
    lookup_context.prefixes = controller._prefixes if controller
    @view_renderer = ActionView::Renderer.new(lookup_context)
  end
  assign(assigns)
  assign_controller(controller)
  _prepare_context
end

def xss_safe? #:nodoc:

:nodoc: 
def xss_safe? #:nodoc:
  true
end