any_view 0.1.0

data/lib/any_view/form_builder/abstract_form_builder.rb

@@ -0,0 +1,128 @@
+module AnyView
+  module Helpers
+    module FormBuilder
+      class AbstractFormBuilder
+        attr_accessor :view_context, :object
+
+        def initialize(view_context, object)
+          @view_context = view_context
+          @object   = object
+          raise "FormBuilder view_context must be initialized!" unless view_context
+          raise "FormBuilder object must be not be nil value. If there's no object, use a symbol instead! (i.e :user)" unless object
+        end
+
+        # f.error_messages
+        def error_messages(options={})
+          @view_context.error_messages_for(@object, options)
+        end
+
+        # f.label :username, :caption => "Nickname"
+        def label(field, options={})
+          options.reverse_merge!(:caption => field.to_s.titleize)
+          @view_context.label_tag(field_id(field), options)
+        end
+
+        # f.hidden_field :session_id, :value => "45"
+        def hidden_field(field, options={})
+          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
+          @view_context.hidden_field_tag field_name(field), options
+        end
+
+        # f.text_field :username, :value => "(blank)", :id => 'username'
+        def text_field(field, options={})
+          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
+          @view_context.text_field_tag field_name(field), options
+        end
+
+        # f.text_area :summary, :value => "(enter summary)", :id => 'summary'
+        def text_area(field, options={})
+          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
+          @view_context.text_area_tag field_name(field), options
+        end
+
+        # f.password_field :password, :id => 'password'
+        def password_field(field, options={})
+          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
+          @view_context.password_field_tag field_name(field), options
+        end
+
+        # f.select :color, :options => ['red', 'green'], :include_blank => true
+        # f.select :color, :collection => @colors, :fields => [:name, :id]
+        def select(field, options={})
+          options.reverse_merge!(:id => field_id(field), :selected => field_value(field))
+          @view_context.select_tag field_name(field), options
+        end
+
+        # f.check_box :remember_me, :value => 'true', :uncheck_value => '0'
+        def check_box(field, options={})
+          unchecked_value = options.delete(:uncheck_value) || '0'
+          options.reverse_merge!(:id => field_id(field), :value => '1')
+          options.merge!(:checked => true) if values_matches_field?(field, options[:value])
+          html = @view_context.check_box_tag field_name(field), options
+          html << hidden_field(field, :value => unchecked_value, :id => nil)
+        end
+
+        # f.radio_button :gender, :value => 'male'
+        def radio_button(field, options={})
+          options.reverse_merge!(:id => field_id(field, options[:value]))
+          options.merge!(:checked => true) if values_matches_field?(field, options[:value])
+          @view_context.radio_button_tag field_name(field), options
+        end
+
+        # f.file_field :photo, :class => 'avatar'
+        def file_field(field, options={})
+          options.reverse_merge!(:id => field_id(field))
+          @view_context.file_field_tag field_name(field), options
+        end
+
+        # f.submit "Update", :class => 'large'
+        def submit(caption="Submit", options={})
+          @view_context.submit_tag caption, options
+        end
+
+        # f.simage_submitubmit "buttons/submit.png", :class => 'large'
+        def image_submit(source, options={})
+          @view_context.image_submit_tag source, options
+        end
+
+        protected
+
+        # Returns the known field types for a formbuilder
+        def self.field_types
+          [:hidden_field, :text_field, :text_area, :password_field, :file_field, :radio_button, :check_box, :select]
+        end
+
+        # Returns the object's models name
+        #   => user_assignment
+        def object_name
+          object.is_a?(Symbol) ? object : object.class.to_s.underscore
+        end
+
+        # Returns true if the value matches the value in the field
+        # field_has_value?(:gender, 'male')
+        def values_matches_field?(field, value)
+          value.present? && (field_value(field).to_s == value.to_s || field_value(field).to_s == 'true')
+        end
+
+        # Returns the value for the object's field
+        # field_value(:username) => "Joey"
+        def field_value(field)
+          @object && @object.respond_to?(field) ? @object.send(field) : ""
+        end
+
+        # Returns the name for the given field
+        # field_name(:username) => "user[username]"
+        def field_name(field)
+          "#{object_name}[#{field}]"
+        end
+
+        # Returns the id for the given field
+        # field_id(:username) => "user_username"
+        # field_id(:gender, :male) => "user_gender_male"
+        def field_id(field, value=nil)
+          value.blank? ? "#{object_name}_#{field}" : "#{object_name}_#{field}_#{value}"
+        end
+      end
+    end
+  end
+end

data/lib/any_view/form_builder/standard_form_builder.rb

@@ -0,0 +1,37 @@
+module AnyView
+  module Helpers
+    module FormBuilder
+      class StandardFormBuilder < AbstractFormBuilder
+
+        # text_field_block(:username, { :class => 'long' }, { :class => 'wide-label' })
+        # text_area_block(:summary, { :class => 'long' }, { :class => 'wide-label' })
+        # password_field_block(:password, { :class => 'long' }, { :class => 'wide-label' })
+        # file_field_block(:photo, { :class => 'long' }, { :class => 'wide-label' })
+        # check_box_block(:remember_me, { :class => 'long' }, { :class => 'wide-label' })
+        # select_block(:color, :options => ['green', 'black'])
+        (self.field_types - [ :hidden_field, :radio_button ]).each do |field_type|
+          class_eval <<-EOF
+          def #{field_type}_block(field, options={}, label_options={})
+            label_options.reverse_merge!(:caption => options.delete(:caption)) if options[:caption]
+            field_html = label(field, label_options)
+            field_html << #{field_type}(field, options)
+            @view_context.content_tag(:p, field_html)
+          end
+          EOF
+        end
+
+        # submit_block("Update")
+        def submit_block(caption, options={})
+          submit_html = self.submit(caption, options)
+          @view_context.content_tag(:p, submit_html)
+        end
+
+        # image_submit_block("submit.png")
+        def image_submit_block(source, options={})
+          submit_html = self.image_submit(source, options)
+          @view_context.content_tag(:p, submit_html)
+        end
+      end
+    end
+  end
+end

data/lib/any_view/form_helpers.rb

@@ -0,0 +1,217 @@
+module AnyView
+  module Helpers
+    module FormHelpers
+      # Constructs a form for object using given or default form_builder
+      # form_for @user, '/register', :id => 'register' do |f| ... end
+      def form_for(object, url, settings={}, &block)
+        builder_class = configured_form_builder_class(settings[:builder])
+        settings[:builder] = builder_class.new(self, object)
+        form_tag(url, settings, &block)
+      end
+
+      # Constructs form fields for an object using given or default form_builder
+      # Used within an existing form to allow alternate objects within one form
+      # fields_for @user.assignment do |assignment| ... end
+      # fields_for :assignment do |assigment| ... end
+      def fields_for(object, settings={}, &block)
+        builder_class = configured_form_builder_class(settings[:builder])
+        fields_html = capture_content(builder_class.new(self, object), &block)
+        concat_content fields_html
+      end
+
+      # Constructs a form without object based on options
+      # form_tag '/register' do ... end
+      def form_tag(url, options={}, &block)
+        options.reverse_merge!(:method => 'post', :action => url)
+
+        @_multi_enc_type = options.delete(:multipart)
+        fake_method = hidden_form_method_field(options[:method])
+        real_method = real_method_for_fake(options[:method])
+        options[:method] = real_method
+        builder = options.delete(:builder)
+
+        inner_form_html = fake_method.to_s
+        inner_form_html += if builder
+                              capture_content(builder, &block)
+                           else
+                             capture_content(&block)
+                           end
+
+        options[:enctype] = "multipart/form-data" if @_multi_enc_type
+        @_multi_enc_type = nil
+        concat_content content_tag('form', inner_form_html, options)
+      end
+
+      # Constructs a field_set to group fields with given options
+      # field_set_tag("Office", :class => 'office-set')
+      # parameters: legend_text=nil, options={}
+      def field_set_tag(*args, &block)
+        options = args.extract_options!
+        legend_text = args[0].is_a?(String) ? args.first : nil
+        legend_html = legend_text.blank? ? '' : content_tag(:legend, legend_text)
+        field_set_content = legend_html + capture_content(&block)
+        concat_content content_tag('fieldset', field_set_content, options)
+      end
+
+      # Constructs list html for the errors for a given object
+      # error_messages_for @user
+      def error_messages_for(record, options={})
+        return "" if record.blank? or record.errors.none?
+        options.reverse_merge!(:header_message => "The #{record.class.to_s.downcase} could not be saved!")
+        error_messages = record.errors.full_messages
+        error_items = error_messages.collect { |er| content_tag(:li, er) }.join("\n")
+        error_html = content_tag(:p, options.delete(:header_message))
+        error_html << content_tag(:ul, error_items, :class => 'errors-list')
+        content_tag(:div, error_html, :class => 'field-errors')
+      end
+
+      # Constructs a label tag from the given options
+      # label_tag :username, :class => 'long-label'
+      # label_tag :username, :class => 'long-label' do ... end
+      def label_tag(name, options={}, &block)
+        options.reverse_merge!(:caption => name.to_s.titleize, :for => name)
+        caption_text = options.delete(:caption) + ": "
+        if block_given? # label with inner content
+          label_content = caption_text + capture_content(&block)
+          concat_content(content_tag(:label, label_content, options))
+        else # regular label
+          content_tag(:label, caption_text, options)
+        end
+      end
+
+      # Constructs a hidden field input from the given options
+      # hidden_field_tag :session_key, :value => "__secret__"
+      def hidden_field_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        input_tag(:hidden, options)
+      end
+
+      # Constructs a text field input from the given options
+      # text_field_tag :username, :class => 'long'
+      def text_field_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        input_tag(:text, options)
+      end
+
+      # Constructs a text area input from the given options
+      # text_area_tag :username, :class => 'long'
+      def text_area_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        content_tag(:textarea, '', options)
+      end
+
+      # Constructs a password field input from the given options
+      # password_field_tag :password, :class => 'long'
+      def password_field_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        input_tag(:password, options)
+      end
+
+      # Constructs a check_box from the given options
+      # options = [['caption', 'value'], ['Green', 'green1'], ['Blue', 'blue1'], ['Black', "black1"]]
+      # options = ['option', 'red', 'yellow' ]
+      # select_tag(:favorite_color, :options => ['red', 'yellow'], :selected => 'green1')
+      # select_tag(:country, :collection => @countries, :fields => [:name, :code])
+      def select_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        collection, fields = options.delete(:collection), options.delete(:fields)
+        options[:options] = options_from_collection(collection, fields) if collection
+        options[:options].unshift('') if options.delete(:include_blank)
+        select_options_html = options_for_select(options.delete(:options), options.delete(:selected)).join
+        options.merge!(:name => "#{options[:name]}[]") if options[:multiple]
+        content_tag(:select, select_options_html, options)
+      end
+
+      # Constructs a check_box from the given options
+      # check_box_tag :remember_me, :value => 'Yes'
+      def check_box_tag(name, options={})
+        options.reverse_merge!(:name => name, :value => '1')
+        input_tag(:checkbox, options)
+      end
+
+      # Constructs a radio_button from the given options
+      # radio_button_tag :remember_me, :value => 'true'
+      def radio_button_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        input_tag(:radio, options)
+      end
+
+      # Constructs a file field input from the given options
+      # file_field_tag :photo, :class => 'long'
+      def file_field_tag(name, options={})
+        @_multi_enc_type = true
+        options.reverse_merge!(:name => name)
+        input_tag(:file, options)
+      end
+
+      # Constructs a submit button from the given options
+      # submit_tag "Create", :class => 'success'
+      def submit_tag(caption="Submit", options={})
+        options.reverse_merge!(:value => caption)
+        input_tag(:submit, options)
+      end
+
+      # Constructs a button input from the given options
+      # button_tag "Cancel", :class => 'clear'
+      def button_tag(caption, options = {})
+        options.reverse_merge!(:value => caption)
+        input_tag(:button, options)
+      end
+
+      # Constructs a submit button from the given options
+      # submit_tag "Create", :class => 'success'
+      def image_submit_tag(source, options={})
+        options.reverse_merge!(:src => image_path(source))
+        input_tag(:image, options)
+      end
+
+      protected
+
+      # Returns an array of option items for a select field based on the given collection
+      # fields is an array containing the fields to display from each item in the collection
+      def options_from_collection(collection, fields)
+        return '' if collection.blank?
+        collection.collect { |item| [ item.send(fields.first), item.send(fields.last) ] }
+      end
+
+      # Returns the options tags for a select based on the given option items
+      def options_for_select(option_items, selected_value=nil)
+        return '' if option_items.blank?
+        option_items.collect do |caption, value|
+          value ||= caption
+          content_tag(:option, caption, :value => value, :selected => selected_value.to_s =~ /#{value}|#{caption}/)
+        end
+      end
+
+      # returns the hidden method field for 'put' and 'delete' forms
+      # Only 'get' and 'post' are allowed within browsers;
+      # 'put' and 'delete' are just specified using hidden fields with form action still 'put'.
+      # hidden_form_method_field('delete') => <input name="_method" value="delete" />
+      def hidden_form_method_field(desired_method)
+        case desired_method
+        when :get, :GET, :POST, :post, /get/i, /post/i
+          ''
+        else
+          hidden_field_tag(:_method, :value => desired_method)
+        end
+      end
+
+      def real_method_for_fake(desired_method)
+        case desired_method
+        when :get, :GET, :delete, :DELETE, /get/i, /delete/i
+          'get'
+        else
+          'post'
+        end
+      end
+
+      # Returns the FormBuilder class to use based on all available setting sources
+      # If explicitly defined, returns that, otherwise returns defaults
+      # configured_form_builder_class(nil) => StandardFormBuilder
+      def configured_form_builder_class(explicit_builder=nil)
+        default_builder = self.respond_to?(:options) && self.options.default_builder
+        explicit_builder || default_builder || FormBuilder::StandardFormBuilder
+      end
+    end
+  end
+end

data/lib/any_view/format_helpers.rb

@@ -0,0 +1,49 @@
+module AnyView
+  module Helpers
+    module FormatHelpers
+
+      # Returns escaped text to protect against malicious content
+      def escape_html(text)
+        Rack::Utils.escape_html(text)
+      end
+      alias h escape_html
+      alias sanitize_html escape_html
+
+      # Returns escaped text to protect against malicious content
+      # Returns blank if the text is empty
+      def h!(text, blank_text = ' ')
+        return blank_text if text.nil? || text.empty?
+        h text
+      end
+
+      # Truncates a given text after a given :length if text is longer than :length (defaults to 30).
+      # The last characters will be replaced with the :omission (defaults to "…") for a total length not exceeding :length.
+      # truncate("Once upon a time in a world far far away", :length => 8) => "Once upon..."
+      def truncate(text, *args)
+        options = args.extract_options!
+        options = options.dup
+        options.reverse_merge!(:length => 30, :omission => "...")
+        if text
+          len = options[:length] - options[:omission].length
+          chars = text
+          (chars.length > options[:length] ? chars[0...len] + options[:omission] : text).to_s
+        end
+      end
+
+
+      # Returns text transformed into HTML using simple formatting rules. Two or more consecutive newlines(\n\n) are considered
+      # as a paragraph and wrapped in <p> tags. One newline (\n) is considered as a linebreak and a <br /> tag is appended.
+      # This method does not remove the newlines from the text.
+      # simple_format("hello\nworld") # => "<p>hello<br/>world</p>"
+      def simple_format(text, html_options={})
+        start_tag = tag('p', html_options.merge(:open => true))
+        text = text.to_s.dup
+        text.gsub!(/\r\n?/, "\n")                    # \r\n and \r -> \n
+        text.gsub!(/\n\n+/, "</p>\n\n#{start_tag}")  # 2+ newline  -> paragraph
+        text.gsub!(/([^\n]\n)(?=[^\n])/, '\1<br />') # 1 newline   -> br
+        text.insert 0, start_tag
+        text << "</p>"
+      end
+    end
+  end
+end

data/lib/any_view/tag_helpers.rb

@@ -0,0 +1,47 @@
+module AnyView
+  module Helpers
+    module TagHelpers
+      # Creates an html input field with given type and options
+      # input_tag :text, :class => "test"
+      def input_tag(type, options = {})
+        options = options.dup
+        options[:type] = type
+        tag(:input, options)
+      end
+
+      # Creates an html tag with given name, content and options
+      # @example
+      #   content_tag(:p, "hello", :class => 'light')
+      #   content_tag(:p, :class => 'dark') do ... end
+      # parameters: content_tag(name, content=nil, options={}, &block)
+      # Writes directly to the buffer
+      def content_tag(*args, &block)
+        name = args.first
+        options = args.extract_options!
+        tag_html = block_given? ? capture_content(options, &block) : args[1]
+        tag_result = tag(name, options.merge(:content => tag_html))
+        block.nil? ? tag_result : concat_content(tag_result)
+      end
+
+      # Creates an html tag with the given name and options
+      # @example
+      #   tag(:br, :style => 'clear:both')
+      #   tag(:p, :content => "hello", :class => 'large')
+      # @return a string
+      def tag(name, options={})
+        content, open_tag = options.delete(:content), options.delete(:open)
+        identity_tag_attributes.each { |attr| options[attr] = attr.to_s if options[attr]  }
+        html_attrs = options.collect { |a, v| v.blank? ? nil : "#{a}=\"#{v}\"" }.compact.join(" ")
+        base_tag = (html_attrs.present? ? "<#{name} #{html_attrs}" : "<#{name}")
+        base_tag << (open_tag ? ">" : (content ? ">#{content}</#{name}>" : " />"))
+      end
+
+      protected
+
+      # Returns a list of attributes which can only contain an identity value (i.e selected)
+      def identity_tag_attributes
+        [:checked, :disabled, :selected, :multiple]
+      end
+    end
+  end
+end

data/lib/any_view/tilt_base.rb

@@ -0,0 +1,94 @@
+require 'tilt'
+
+class Tilt::Template
+  def render_with_any_view(scope=Object.new, locals = {}, &blk)
+    scope.template_type = self.class if scope.respond_to?(:template_type=)
+    render_without_any_view(scope, locals, &blk)
+  end
+  alias_method :render_without_any_view, :render
+  alias_method :render, :render_with_any_view
+end
+
+module AnyView
+  # Provides capture and concat methods for use inside templates with the Tilt gem.
+  module TiltBase
+    class Error < StandardError; end
+    class CaptureMethodNotFound < Error; end
+    class ContentMethodNotFound < Error; end
+
+    def self.included(base)
+      base.class_eval do
+        attr_writer :template_type unless self.method_defined?(:template_type=)
+        attr_reader :template_type unless self.method_defined?(:template_type)
+      end
+    end
+
+    class << self
+      # Keeps track of the concatenation methods for each template type.
+      # If you have your own template types, then you should add them here
+      def concat_methods
+        @concat_methods ||= {}
+      end
+
+      def capture_methods
+        @capture_methods ||= {}
+      end
+
+      def capture_method_for(template)
+        capture_methods[template]
+      end
+
+      def concat_method_for(template)
+        concat_methods[template]
+      end
+    end
+
+    capture_methods[::Tilt::HamlTemplate  ] = :_haml_capture
+    capture_methods[::Tilt::ERBTemplate   ] = :_erb_capture
+    capture_methods[::Tilt::ErubisTemplate] = :_erb_capture
+
+    concat_methods[ ::Tilt::HamlTemplate  ] = :_haml_concat
+    concat_methods[ ::Tilt::ERBTemplate   ] = :_erb_concat
+    concat_methods[ ::Tilt::ErubisTemplate] = :_erb_concat
+
+    def capture_content(*args, &blk)
+      opts = args.extract_options!
+      opts[:template_type]  ||= template_type
+      capture_method = AnyView::TiltBase.capture_method_for(opts[:template_type])
+
+      raise CaptureMethodNotFound, "Capture Method not found for Template Type: #{opts[:template_type].inspect}" unless capture_method
+      send(capture_method, *args, &blk)
+    end
+
+    def concat_content(string, opts = {})
+      opts[:template_type] ||= template_type
+      concat_method = AnyView::TiltBase.concat_method_for(opts[:template_type])
+
+      raise ConcatMethodNotFound, "Concat Method not found for Template Type: #{opts[:template_type].inspect}" unless concat_method
+      send(concat_method, string)
+    end
+
+    def _haml_capture(*args, &block)
+      with_haml_buffer Haml::Buffer.new(nil, :encoding => "UTF-8") do
+        capture_haml(*args, &block)
+      end
+    end
+
+    def _erb_capture(*args, &block)
+      _out_buf, @_out_buf = @_out_buf, ""
+      block.call(*args)
+      ret = @_out_buf
+      @_out_buf = _out_buf
+      ret
+    end
+
+    def _haml_concat(string)
+      haml_concat(string)
+    end
+
+    def _erb_concat(string)
+      @_out_buf << string
+    end
+  end
+end
+

data/lib/any_view.rb

@@ -0,0 +1,30 @@
+require 'dirge'
+require ~'./any_view/core_ext/string'
+require ~'./any_view/core_ext/hash'
+require ~'./any_view/core_ext/array'
+
+module AnyView
+  autoload :TiltBase,         ~'./any_view/tilt_base'
+
+  module Helpers
+    autoload :TagHelpers,      ~'./any_view/tag_helpers'
+    autoload :AssetTagHelpers, ~'./any_view/asset_tag_helpers'
+    autoload :FormatHelpers,   ~'./any_view/format_helpers'
+    autoload :FormHelpers,     ~'./any_view/form_helpers'
+
+    module FormBuilder
+      autoload :AbstractFormBuilder,  ~'./any_view/form_builder/abstract_form_builder'
+      autoload :StandardFormBuilder,  ~'./any_view/form_builder/standard_form_builder'
+    end
+  end
+
+
+  def self.included(base)
+    ah = AnyView::Helpers
+    base.class_eval do
+      include ah::TagHelpers, ah::AssetTagHelpers, ah::FormHelpers, ah::FormatHelpers
+    end
+  end
+end
+
+

data/test/fixtures/basic_form_for.erb

@@ -0,0 +1,3 @@
+<% form_for MarkupUser.new, '/register', :id => 'register', :method => :post do |f| %>
+  <div>Demo</div>
+<% end %>

data/test/fixtures/builder_type_form_for.erb

@@ -0,0 +1,3 @@
+<% form_for MarkupUser.new, "/register", :builder => AnyView::Helpers::FormBuilder::AbstractFormBuilder do |f| %>
+  <%= f.text_field_block(:name) %>
+<% end %>

data/test/fixtures/capture_concat.erb

@@ -0,0 +1,14 @@
+<% @content = captured_content do %>
+  <span>Captured Line 1</span>
+  <span>Captured Line 2</span>
+<% end %>
+<%= @content %>
+
+<% concat_in_p('Concat Line 3') %>
+
+<% determine_block_is_template('erb') do %>
+  <span>This is erb</span>
+  <span>This is erb</span>
+<% end %>
+  
+<% ruby_not_template_block %>

data/test/fixtures/capture_concat.haml

@@ -0,0 +1,13 @@
+- @content = captured_content do
+  %span Captured Line 1
+  %span Captured Line 2
+= @content
+
+- concat_in_p('Concat Line 3')
+
+- determine_block_is_template('haml') do
+  %span This is haml
+  %span This is haml
+  
+- ruby_not_template_block
+  

data/test/fixtures/content_for.erb

@@ -0,0 +1,11 @@
+<% content_for :demo do %>
+  <h1>This is content yielded from a content_for</h1>
+<% end %>
+  
+<div class='demo'><%= yield_content :demo %></p>
+  
+<% content_for :demo2 do |fname, lname| %>
+  <h1>This is content yielded with name <%= fname + " " + lname %></h1>
+<% end %>
+  
+<div class='demo2'><%= yield_content :demo2, "Johnny", "Smith" %></div>

data/test/fixtures/content_for.haml

@@ -0,0 +1,9 @@
+- content_for :demo do
+  %h1 This is content yielded from a content_for
+  
+.demo= yield_content :demo
+
+- content_for :demo2 do |fname, lname|
+  %h1 This is content yielded with name #{fname + " " + lname}
+  
+.demo2= yield_content :demo2, "Johnny", "Smith"

data/test/fixtures/content_tag.erb

@@ -0,0 +1,11 @@
+<%= content_tag :p, "Test 1", :class => 'test', :id => "test1" %>
+
+<%= content_tag :p, "Test 2" %>
+
+<% content_tag(:p, :class => 'test', :id => 'test3') do %>
+  <span>Test 3</span>
+<% end %>
+
+<% content_tag(:p) do %>
+  <span>Test 4</span>
+<% end %>