masterview 0.2.5 → 0.3.0

data/lib/rexml/parsers/sax2parser_with_doctype_fix.rb

@@ -0,0 +1,243 @@
+#!/usr/bin/env ruby
+
+currentPath = File.dirname(__FILE__)
+require File.join( currentPath, 'baseparser_with_doctype_fix' )
+require 'rexml/parseexception'
+require 'rexml/namespace'
+require 'rexml/text'
+
+# REXML version 3.1.5 and lower have a bug which does not trigger the doctype event for sax2 listener
+# We have submitted a fix to REXML ticket number 92 with some test cases and a patch for 3.1.5
+# http://www.germane-software.com/projects/rexml/ticket/92
+# Until that is deployed this patched version of the REXML sax2 parser has the applied fixes
+# The fix also requires a patched baseparser which is required above
+
+module REXML
+        module Parsers
+    # SAX2Parser
+                class SAX2ParserWithDoctypeFix
+                        def initialize source
+                                @parser = BaseParserWithDoctypeFix.new(source)
+                                @listeners = []
+                                @procs = []
+                                @namespace_stack = []
+                                @has_listeners = false
+                                @tag_stack = []
+        @entities = {}
+                        end
+
+      def add_listener( listener )
+        @parser.add_listener( listener )
+      end
+
+                        # Listen arguments:
+                        #
+                        # Symbol, Array, Block
+                        #       Listen to Symbol events on Array elements
+                        # Symbol, Block
+                        #   Listen to Symbol events
+                        # Array, Listener
+                        #       Listen to all events on Array elements
+                        # Array, Block
+                        #       Listen to :start_element events on Array elements
+                        # Listener
+                        #       Listen to All events
+                        #
+                        # Symbol can be one of: :start_element, :end_element,
+                        # :start_prefix_mapping, :end_prefix_mapping, :characters,
+                        # :processing_instruction, :doctype, :attlistdecl, :elementdecl,
+                        # :entitydecl, :notationdecl, :cdata, :xmldecl, :comment
+      #
+      # There is an additional symbol that can be listened for: :progress.
+      # This will be called for every event generated, passing in the current
+      # stream position.
+                        #
+                        # Array contains regular expressions or strings which will be matched
+                        # against fully qualified element names.
+                        #
+                        # Listener must implement the methods in SAX2Listener
+                        #
+                        # Block will be passed the same arguments as a SAX2Listener method would
+                        # be, where the method name is the same as the matched Symbol.
+                        # See the SAX2Listener for more information.
+                        def listen( *args, &blok )
+                                if args[0].kind_of? Symbol
+                                        if args.size == 2
+                                                args[1].each { |match| @procs << [args[0], match, blok] }
+                                        else
+                                                add( [args[0], nil, blok] )
+                                        end
+                                elsif args[0].kind_of? Array
+                                        if args.size == 2
+                                                args[0].each { |match| add( [nil, match, args[1]] ) }
+                                        else
+                                                args[0].each { |match| add( [ :start_element, match, blok ] ) }
+                                        end
+                                else
+                                        add([nil, nil, args[0]])
+                                end
+                        end
+
+                        def deafen( listener=nil, &blok )
+                                if listener
+                                        @listeners.delete_if {|item| item[-1] == listener }
+                                        @has_listeners = false if @listeners.size == 0
+                                else
+                                        @procs.delete_if {|item| item[-1] == blok }
+                                end
+                        end
+
+                        def parse
+                                @procs.each { |sym,match,block| block.call if sym == :start_document }
+                                @listeners.each { |sym,match,block|
+                                        block.start_document if sym == :start_document or sym.nil?
+                                }
+                                root = context = []
+                                while true
+                                        event = @parser.pull
+                                        case event[0]
+                                        when :end_document
+                                                handle( :end_document )
+                                                break
+                                        when :start_doctype
+                                                handle( :doctype, *event[1..-1])
+                                        when :end_doctype
+                                                context = context[1]
+                                        when :start_element
+                                                @tag_stack.push(event[1])
+                                                # find the observers for namespaces
+                                                procs = get_procs( :start_prefix_mapping, event[1] )
+                                                listeners = get_listeners( :start_prefix_mapping, event[1] )
+                                                if procs or listeners
+                                                        # break out the namespace declarations
+                                                        # The attributes live in event[2]
+                                                        event[2].each {|n, v| event[2][n] = @parser.normalize(v)}
+                                                        nsdecl = event[2].find_all { |n, value| n =~ /^xmlns(:|$)/ }
+                                                        nsdecl.collect! { |n, value| [ n[6..-1], value ] }
+                                                        @namespace_stack.push({})
+                                                        nsdecl.each do |n,v|
+                                                                @namespace_stack[-1][n] = v
+                                                                # notify observers of namespaces
+                                                                procs.each { |ob| ob.call( n, v ) } if procs
+                                                                listeners.each { |ob| ob.start_prefix_mapping(n, v) } if listeners
+                                                        end
+                                                end
+                                                event[1] =~ Namespace::NAMESPLIT
+                                                prefix = $1
+                                                local = $2
+                                                uri = get_namespace(prefix)
+                                                # find the observers for start_element
+                                                procs = get_procs( :start_element, event[1] )
+                                                listeners = get_listeners( :start_element, event[1] )
+                                                # notify observers
+                                                procs.each { |ob| ob.call( uri, local, event[1], event[2] ) } if procs
+                                                listeners.each { |ob|
+                                                        ob.start_element( uri, local, event[1], event[2] )
+                                                } if listeners
+                                        when :end_element
+                                                @tag_stack.pop
+                                                event[1] =~ Namespace::NAMESPLIT
+                                                prefix = $1
+                                                local = $2
+                                                uri = get_namespace(prefix)
+                                                # find the observers for start_element
+                                                procs = get_procs( :end_element, event[1] )
+                                                listeners = get_listeners( :end_element, event[1] )
+                                                # notify observers
+                                                procs.each { |ob| ob.call( uri, local, event[1] ) } if procs
+                                                listeners.each { |ob|
+                                                        ob.end_element( uri, local, event[1] )
+                                                } if listeners
+
+                                                namespace_mapping = @namespace_stack.pop
+                                                # find the observers for namespaces
+                                                procs = get_procs( :end_prefix_mapping, event[1] )
+                                                listeners = get_listeners( :end_prefix_mapping, event[1] )
+                                                if procs or listeners
+                                                        namespace_mapping.each do |prefix, uri|
+                                                                # notify observers of namespaces
+                                                                procs.each { |ob| ob.call( prefix ) } if procs
+                                                                listeners.each { |ob| ob.end_prefix_mapping(prefix) } if listeners
+                                                        end
+                                                end
+                                        when :text
+            #normalized = @parser.normalize( event[1] )
+            #handle( :characters, normalized )
+            copy = event[1].clone
+            @entities.each { |key, value| copy = copy.gsub("&#{key};", value) }
+            copy.gsub!( Text::NUMERICENTITY ) {|m|
+              m=$1
+              m = "0#{m}" if m[0] == ?x
+              [Integer(m)].pack('U*')
+            }
+            handle( :characters, copy )
+          when :entitydecl
+            @entities[ event[1] ] = event[2] if event.size == 3
+                                                handle( *event )
+                                        when :processing_instruction, :comment, :attlistdecl,
+                                                :elementdecl, :cdata, :notationdecl, :xmldecl
+                                                handle( *event )
+                                        end
+          handle( :progress, @parser.position )
+                                end
+                        end
+
+                        private
+                        def handle( symbol, *arguments )
+                                tag = @tag_stack[-1]
+                                procs = get_procs( symbol, tag )
+                                listeners = get_listeners( symbol, tag )
+                                # notify observers
+                                procs.each { |ob| ob.call( *arguments ) } if procs
+                                listeners.each { |l|
+                                        l.send( symbol.to_s, *arguments )
+                                } if listeners
+                        end
+
+                        # The following methods are duplicates, but it is faster than using
+                        # a helper
+                        def get_procs( symbol, name )
+                                return nil if @procs.size == 0
+                                @procs.find_all do |sym, match, block|
+          #puts sym.inspect+"=="+symbol.inspect+ "\t"+match.inspect+"=="+name.inspect+ "\t"+( (sym.nil? or symbol == sym) and ((name.nil? and match.nil?) or match.nil? or ( (name == match) or (match.kind_of? Regexp and name =~ match)))).to_s
+                                        (
+                                                (sym.nil? or symbol == sym) and
+                                                ((name.nil? and match.nil?) or match.nil? or (
+                                                        (name == match) or
+                                                        (match.kind_of? Regexp and name =~ match)
+                                                        )
+                                                )
+                                        )
+                                end.collect{|x| x[-1]}
+                        end
+                        def get_listeners( symbol, name )
+                                return nil if @listeners.size == 0
+                                @listeners.find_all do |sym, match, block|
+                                        (
+                                                (sym.nil? or symbol == sym) and
+                                                ((name.nil? and match.nil?) or match.nil? or (
+                                                        (name == match) or
+                                                        (match.kind_of? Regexp and name =~ match)
+                                                        )
+                                                )
+                                        )
+                                end.collect{|x| x[-1]}
+                        end
+
+                        def add( pair )
+                                if pair[-1].respond_to? :call
+                                        @procs << pair unless @procs.include? pair
+                                else
+                                        @listeners << pair unless @listeners.include? pair
+                                        @has_listeners = true
+                                end
+                        end
+
+                        def get_namespace( prefix )
+        uris = (@namespace_stack.find_all { |ns| not ns[prefix].nil? }) ||
+                                        (@namespace_stack.find { |ns| not ns[nil].nil? })
+                                uris[-1][prefix] unless uris.nil? or 0 == uris.size
+                        end
+                end
+        end
+end

data/test/directive_test_helper.rb

@@ -0,0 +1,135 @@
+require 'test/unit'
+require 'test/unit/assertions'
+currentPath = File.dirname(__FILE__)
+require File.join( currentPath, '../lib/masterview' )
+
+# Mixin class for testing directive implementations.
+#
+# Provides convenience services for constructing a template document element
+# to use as a test fixture, constructing the directive handler for the
+# directive being tested, and modelling the template document element
+# processing events that a directive uses to hook up its handlers.
+#
+module DirectiveTestHelpers
+
+  MasterView::IOMgr.erb = MasterView::MIO::StringHashMIOTree.new({}, '.rhtml', :logging => true)
+  TestHelperRenderer = MasterView::TemplateProcessing::Renderer.new(:output_mio_tree => MasterView::IOMgr.erb)
+
+  MVCodeBaseDirDir = File.expand_path( File.join(File.dirname(__FILE__), '../lib/masterview' ) )
+  BuiltinDirectivesDir = "#{MasterView::ConfigSettings.mv_code_base_dir}/directives"
+  #put in some paranioa checking here...
+  if BuiltinDirectivesDir != "#{MVCodeBaseDirDir}/directives"
+    raise AssertionError, "MV dir resolution problem: MasterView::ConfigSettings.mv_code_base_dir=#{MasterView::ConfigSettings.mv_code_base_dir}, #{self.name}::BuiltinDirectivesDir=#{BuiltinDirectivesDir},"
+  end
+
+  # provide the equivalent of require 'appowner/directives/#{file_baseName}'
+  # for unit tests so that the directive loading happens in the proper context.
+  def self.load_directive(directive_file_name, directive_dir_path)
+    directive_file_path = "#{File.expand_path(directive_dir_path)}/#{directive_file_name}"
+    MasterView::DirectiveRegistry.current.load_directive_file( directive_file_path )
+  end
+
+  # provide the equivalent of require 'masterview/directives/#{file_baseName}'
+  # for unit tests so that the directive loading happens in the proper context
+  # for a built-in masterview directive in the standard mv: namespace.
+  def self.load_masterview_directive(directive_file_name)
+    directive_file_path = "#{BuiltinDirectivesDir}/#{directive_file_name}"
+    MasterView::DirectiveRegistry.current.load_directive_file( directive_file_path )
+  end
+
+  # brute force check everything that's supposed to be bolted down is in hardened metadata
+  def check_metadata(directive_class, expected_namespace, expected_attributeName)
+    check_metadata_keys(directive_class)
+    check_metadata_values(directive_class, expected_namespace, expected_attributeName)
+  end
+
+  # brute force check everything that's supposed to be bolted down is in hardened metadata
+  def check_metadata_values(directive_class, expected_namespace, expected_attributeName)
+    assert_equal expected_namespace, directive_class.namespace_name
+    assert_equal "#{expected_namespace}:", directive_class.namespace_prefix
+    assert_equal expected_attributeName, directive_class.attribute_name
+    assert_equal "#{expected_namespace}:#{expected_attributeName}", directive_class.attribute_qname
+  end
+
+  # brute force check everything that's supposed to be bolted down is in hardened metadata
+  def check_metadata_keys(directive_class)
+    dc_md = directive_class.metadata_values
+    expected_keys = MasterView::DirectiveMetadata::MARKUP_PROPERTY_NAMES
+    expected_keys.each { |key|
+      assert dc_md.has_key?(key), "MISSING MD KEY #{key.inspect}: #{dc_md.inspect}"
+    }
+    disallowed_keys = [ :namespace_name ]
+    disallowed_keys.each { |key|
+      assert ! dc_md.has_key?(key), "UNEXPECTED #{key.inspect} in metadata: #{dc_md.inspect}"
+    }
+  end
+
+  # create a template document processing element to use in a directive test
+  def create_template_element( tag_name='dummy', other_args={} )
+    attributes = other_args.fetch(:attributes, {})
+    mode_type = other_args.fetch(:mode_type, :normal)
+    parent_tag = other_args.fetch(:parent_tag, nil)
+    content = other_args.fetch(:content, nil)
+    @directives = MasterView::TemplateProcessing::DirectiveSet.new
+    @element_tag = MasterView::TemplateProcessing::Tag.new(@directives, tag_name, attributes, mode_type, parent_tag, nil, TestHelperRenderer)
+    #assert element_content == [], 'element can contain text chunks as well as child elements'
+    if content
+      if content.is_a? String
+        @element_tag.content << content
+      else
+        @element_tag.content.concat content
+      end
+    end
+    @element_tag
+  end
+
+  # construct a directive to test on the template element
+  def create_directive( directive_class, attr_value )
+    #??@directives = MasterView::TemplateProcessing::DirectiveSet.new
+    directive_instance = directive_class.new(attr_value)
+    @directives.directives.clear
+    @directives << directive_instance
+    directive_instance
+  end
+
+  def append_default_render_handler
+    @directives << MasterView::TemplateProcessing::SimpleRenderHandler.new
+  end
+
+  # Answer the directives configured to process the test element
+  # Ordinarily exactly one, the subject of the unit test
+  def element_directives
+    @directives.directives
+  end
+
+  # construct the test environment to evaluate the specified element processing event
+  def create_element_event_processor( event_name, context_values={} )
+    dcs = @directives.determine_dcs(event_name)
+    dcs.context = @element_tag.create_context( context_values )
+    dcs
+  end
+
+  # Evaluate the specified element processing event on the test element.
+  # Return the output contributed to the element rendering by this event.
+  def render_element_event( event_name, context_values={} )
+    dcs = create_element_event_processor( event_name, context_values )
+    render_result = dcs.render
+    render_result.flatten.join  # assemble array of html chunks into final string
+  end
+
+  # answer the attributes hash for the element being tested
+  def element_attrs
+    @element_tag.attributes
+  end
+
+  # answer the value of the specified attribute of the element being tested
+  def element_attr_value( attr_name )
+    @element_tag.attributes[attr_name]
+  end
+
+  # answer the content of the element being tested
+  def element_content
+    @element_tag.content.flatten.join  # assemble array of html chunks into final string
+  end
+
+end

data/test/fixtures/directives/id_check.rb

@@ -0,0 +1,18 @@
+module MasterView
+  module DirectiveTests
+
+    # Example directive which does.. nothing
+    class IdCheck < MasterView::DirectiveBase
+
+      metadata :description => 'Silly example directive which checks id/name attributes'
+
+      ##attr_arg :foo,....
+      #event :stag do
+      #...something
+      #end
+
+    end
+
+  end
+end
+

data/test/fixtures/directives/test_directive_events.rb

@@ -0,0 +1,70 @@
+
+module MasterView
+  module DirectiveTests
+
+    class TestEventsDirective < MasterView::DirectiveBase
+
+      DEBUG_MD_LOADING = false
+
+      if DEBUG_MD_LOADING
+        STDOUT.puts "\n###DEBUG #{self.name} METADATA LOADING ###"
+        STDOUT.puts "...DirectiveMetadataRegistry (#{MasterView::DirectiveMetadata::DirectiveMetadataRegistry[self.name].object_id}): #{MasterView::DirectiveMetadata::DirectiveMetadataRegistry[self.name].inspect})"
+        STDOUT.puts "...before md decls: metadata_values=#{metadata_values.object_id}: #{metadata_values.inspect}"
+      end
+
+      metadata :namespace => 'mvtest', :attribute_name => 'test_events',
+        :priority => 'Low'
+
+      if DEBUG_MD_LOADING
+        STDOUT.puts "AFTER metadata DECLS:"
+        STDOUT.puts "...DirectiveMetadataRegistry (#{MasterView::DirectiveMetadata::DirectiveMetadataRegistry[self.name].object_id}): #{MasterView::DirectiveMetadata::DirectiveMetadataRegistry[self.name].inspect})"
+        STDOUT.puts "...after md decls: metadata_values #{metadata_values.object_id}: #{metadata_values.inspect}"
+      end
+
+      event :stag do
+        render ' stag '
+        render render_result
+        render ' stagend '
+      end
+
+      # sub-event notification w/in document content processing
+      def characters(dcs)
+        ret = []
+        ret << ' charsstart '
+        ret << dcs.render
+        ret << ' charsend '
+      end
+
+      # sub-event notification w/in document content processing
+      def comment(dcs)
+        ret = []
+        ret << ' commentstart '
+        ret << dcs.render
+        ret << ' commentend '
+      end
+
+      # sub-event notification w/in document content processing
+      def cdata(dcs)
+        ret = []
+        ret << ' cdatastart '
+        ret << dcs.render
+        ret << ' cdataend '
+      end
+
+      event :etag do
+        render ' etag '
+        render render_result
+        render ' etagend '
+      end
+
+      event :before_child_title_stag do
+        render ' before_child_title_stag '
+      end
+
+      event :child_title_content do
+        render attr_value
+      end
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -5,21 +5,34 @@ require File.join( currentPath, '../lib/masterview' )
 
 MasterView::OmitGeneratedComments = true #turn off the generated comments to make it easier for us to test
 
+module MasterView
+  module ParserMock
+    def self.createMockDCS
+      dcs = OpenStruct.new
+      dcs.context = {}
+      dcs.context[:tag] = OpenStruct.new
+      dcs.context[:tag].attributes = CaseInsensitiveHash.new
+      dcs
+    end
+  end
+end
 
 module Test
   module Unit
     module Assertions
-        def assert_template_result(expected, template, options={}, message=nil)
+        def assert_template_result(expected, template, options={}, message=nil, normalize_white_space=true)
           #options[:template_pathname] = Pathname.for_path(options.delete(:template_path)) if options[:template_path]
           output_hash = {}
           full_options = options.merge( { :output_mio_tree => MasterView::IOMgr.erb } )
           MasterView::Parser.parse(template, full_options)
-          MasterView::IOMgr.erb.string_hash.each do |key,value|
-            value.gsub!( /([^=]>)\s+/, '\1' ) #remove whitespace after tag but not => 
-            value.gsub!( /(\s{2,}|\n\s*)/, ' ') #change double space or newline and spaces into single space 
+          if normalize_white_space
+            MasterView::IOMgr.erb.string_hash.each do |key,value|
+              value.gsub!( /([^=]>)\s+/, '\1' ) #remove whitespace after tag but not =>
+              value.gsub!( /(\s{2,}|\n\s*)/, ' ') #change double space or newline and spaces into single space
+            end
           end
           assert_equal expected, MasterView::IOMgr.erb.string_hash, message
-        end 
+        end
     end
   end
 end

data/test/tmp/views/layouts/product.rhtml

@@ -1,35 +1,35 @@
 <html>
   <head>
     <title>Product: <%= controller.action_name %></title>
-    <%= stylesheet_link_tag 'scaffold' %>
+    <%= stylesheet_link_tag( 'scaffold' ) %>
 
       <!-- 
            These stylesheets below are for design time use to allow working with only one visible section at a time, especially 
            when trying to use absolute positioning. You may comment/uncomment which ever section you wish to work with.
 	   You may comment all of them out to work with all at design time. These stylesheets will not be used at runtime
        -->
-      
+      <%=  %>
       <!--  <link rel="stylesheet" type="text/css" href="./extra/show_only_edit.css" mv:replace=""/>  -->
       <!--  <link rel="stylesheet" type="text/css" href="./extra/show_only_show.css" mv:replace=""/>  -->
       <!--  <link rel="stylesheet" type="text/css" href="./extra/show_only_list.css" mv:replace=""/>  -->
       <!--  <link rel="stylesheet" type="text/css" href="./extra/show_only_destroy.css" mv:replace=""/>  -->
 
-      <%= javascript_include_tag :defaults %>
-      
-      
-      
-      
+      <%= javascript_include_tag( :defaults ) %>
+      <%=  %>
+      <%=  %>
+      <%=  %>
+      <%=  %>
   </head>
   <body>
 
-    <% if @flash[:notice] %><div class="messages"><%= @flash[:notice] %></div><% end %>
+    <% if( @flash[:notice] ) -%><div class="messages"><%= @flash[:notice] %></div><% end -%>
 
     <div class="main">
       <%= @content_for_layout %>
     </div>
 
-    
-    
+    <%=  %>
+    <%=  %>
 
     </body>
 </html>

data/test/tmp/views/product/_form.rhtml

@@ -6,22 +6,22 @@
 
   <div class="record">
     <div class="label"><label for="product_name">Name:</label></div>
-    <div class="field"><%= text_field 'product', 'name' %></div>
+    <div class="field"><%= text_field( 'product', 'name' ) %></div>
   </div>
 
   <div class="record">
     <div class="label"><label for="product_description">Description:</label></div>
-    <div class="field"><%= text_area 'product', 'description', :rows => 5 %></div>
+    <div class="field"><%= text_area( 'product', 'description', :rows => 5 ) %></div>
   </div>
 
   <div class="record">
     <div class="label"><label for="product_cost">Cost:</label></div>
-    <div class="field"><%= text_field 'product', 'cost' %></div>
+    <div class="field"><%= text_field( 'product', 'cost' ) %></div>
   </div>
 
   <div class="record">
     <div class="label"><label for="product_price">Price:</label></div>
-    <div class="field"><%= text_field 'product', 'price' %></div>
+    <div class="field"><%= text_field( 'product', 'price' ) %></div>
   </div>
 
 </div>

data/test/tmp/views/product/_product.rhtml

@@ -5,9 +5,9 @@
 <td class="td_description"><%= h product.send(:description) %></td>
 <td class="td_cost"><%= h product.send(:cost) %></td>
 <td class="td_price"><%= h product.send(:price) %></td>
-<td><%= link_to 'Show', :action => 'show', :id => product %></td>
-<td><%= link_to 'Edit', :action => 'edit', :id => product %></td>
-<td><%= link_to 'Destroy', :action => 'destroy', :id => product %></td>
+<td><%= link_to( 'Show', { :action => 'show', :id => product }, :class => "show_link" ) %></td>
+<td><%= link_to( 'Edit', { :action => 'edit', :id => product }, :class => "edit_link" ) %></td>
+<td><%= link_to( 'Destroy', { :action => 'destroy', :id => product }, :class => "destroy_link" ) %></td>
 
 <!-- [eolistline:product] -->
 

data/test/tmp/views/product/destroy.rhtml

@@ -2,8 +2,8 @@
 	<div class="product_destroy sidebar">
 	  <h1>Tasks:</h1>
 	  <ul>
-	    <li><%= link_to 'Back to overview', :action => 'list' %></li>
-	    <li><%= link_to 'Show this product', :action => 'show', :id => @product.id %></li>
+	    <li><%= link_to( 'Back to overview', { :action => 'list' }, :class => "list_link" ) %></li>
+	    <li><%= link_to( 'Show this product', { :action => 'show', :id => @product.id }, :class => "show_link" ) %></li>
 	  </ul> 
 	</div>
 
@@ -14,14 +14,14 @@
 
 	  <div class="messages">Are you sure you want to delete this item?</div>
 	  <br />
-	    <%= form_tag :action => 'destroy', :id => @product.id %>
+	    <%= form_tag( :action => 'destroy', :id => @product.id ) %>
 	      <%= render :partial => 'show' %>
 
 	      <br />
 	      <div class="product_edit operations">
-		<%= submit_tag 'Delete' %>
+		<%= submit_tag( 'Delete', :class => "save_button" ) %>
 		<input class="cancel_button" onclick="window.location.href = '<%= url_for :action => %q{list} %>';" style="width: auto;" type="button" value="Cancel" />         
 	      </div>
-	    <%= end_form_tag %>
+	    </form>
 	  </div>
 	</div>

data/test/tmp/views/product/edit.rhtml

@@ -2,14 +2,14 @@
 	  <div class="product_edit sidebar">
 	    <h1>Tasks:</h1>
 	    <ul>
-	      <li><%= link_to 'Back to overview', :action => 'list' %></li>
+	      <li><%= link_to( 'Back to overview', { :action => 'list' }, :class => "list_link" ) %></li>
 	    </ul> 
 	  </div>
 
 	  <div class="product_edit content">
 	    <h1>Products</h1>
 
-	    <%= form_tag :action => 'edit', :id => @product.id %>
+	    <%= form_tag( :action => 'edit', :id => @product.id ) %>
 
 	    <div class="form">	
 	      <h2>Editing product</h2>
@@ -18,9 +18,9 @@
 
 	    <br />
 	    <div class="product_edit operations">
- 	      <%= submit_tag 'OK' %>
+ 	      <%= submit_tag( 'OK', :class => "primary save_button" ) %>
 	      <input class="cancel_button" onclick="window.location.href = '<%= url_for :action => %q{list} %>';" style="width: auto;" type="button" value="Cancel" />         </div>
 
-	    <%= end_form_tag %>
+	    </form>
 	  </div>
 	</div>