masterview 0.2.5 → 0.3.0

data/lib/masterview/directive_registry.rb

@@ -10,25 +10,146 @@ module MasterView
   # 
   class DirectiveRegistry
 
-    # Answer the list of directive classes
+    DEBUG_TRACE_LOADING = false #:nodoc:  ##DEBUG##
+    TRACE_MD_HARDENING_SUBJECT = nil #'MasterView::DirectiveTests::TestEventsDirective'
+    DEBUG_BUILTIN_DIRECTIVE_REGISTRATION = true #:nodoc:
+    DEBUG_CURRENT = false  #:nodoc:
+
+    # The DirectiveRegistry for managing the loaded directives available 
+    # for processing template markup.
+    # #
+    # DirectiveRegistry.current is ordinarily configured to load
+    # the directives registered on the DirectiveLoadPath.current.
+    def self.current
+      @@current
+    end
+
+    # Set the current directives registry for template processing.
+    # Ordinarily done once during masterview initialization.
+    def self.current=(registry) #:nodoc:
+      if self.class_variables.include?('@@current') && @@current && registry
+        # HACK: need to preserve the list of loaded classes.
+        # this shouldn't ordinarily happen, but repeated class loading
+        # occurs during, ah, say... test suite runs, yes!!
+        registry.update_loaded_classes_hack( @@current.loaded_classes )
+      end
+      @@current = registry
+      if DEBUG_CURRENT
+        STDOUT.puts "\n****#{self.name}.current set: #{current.object_id}"
+        STDOUT.puts "...#{current.inspect}\n"
+      end
+    end
+
+    def update_loaded_classes_hack(already_loaded_classes) #:nodoc:
+      @loaded_classes.concat( already_loaded_classes )
+    end
+
+    # Register default namespaces for directive metadata
+    # Should be invoked once during MasterView initialization
+    def self.register_default_namespaces(ns_prefix_masterview, ns_prefix_extensions) #:nodoc:
+      raise ArgumentError, "Invalid masterview namespace prefix '#{ns_prefix_masterview}'" if ns_prefix_masterview[-1..-1] != ':'
+      raise ArgumentError, "Invalid extensions namespace prefix '#{ns_prefix_extensions}'" if ns_prefix_extensions[-1..-1] != ':'
+      @@metadata_defaults_masterview = {
+        :namespace => ns_prefix_masterview[0...-1],
+        :namespace_prefix => ns_prefix_masterview,
+        }
+      @@metadata_defaults_extensions = {
+        :namespace => ns_prefix_extensions[0...-1],
+        :namespace_prefix => ns_prefix_extensions,
+        }
+      #assert NotReallyNecessary, 'because we'll just make sure we code up the right stuff here'
+      DirectiveMetadata.validate_metadata_props! @@metadata_defaults_masterview
+      DirectiveMetadata.validate_metadata_props! @@metadata_defaults_extensions
+    end
+
+    # Answer the namespace prefix of directives in the standard MasterView namespace.
+    def mv_namespace_prefix
+      ##ISSUE: needs work??  Does this need to be an inst var of the registry??
+      @@metadata_defaults_masterview[:namespace_prefix]
+    end
+
+    # Answer the namespace prefix of directives in the default MasterView 
+    # extensions directives namespace.
+    def mv_extensions_namespace_prefix
+      ##ISSUE: needs work??  Does this need to be an inst var of the registry??
+      @@metadata_defaults_extensions[:namespace_prefix]
+    end
+
+    # Answer the list of directive classes which are loaded in the current configuration.
     attr_reader :loaded_classes
 
-    def initialize() #:nodoc:
+    # Answer a list of all namespaces in use
+    def loaded_namespaces
+      @directive_namespaces #??.clone for paranoid safety?
+    end
+
+    # Answer the fully-qualified names of the registered directives
+    def registered_directive_names
+      @directive_classes.keys
+    end
+
+    # Answer the the registered directives
+    def registered_directives
+      @directive_classes.values
+    end
+
+    # Hash containing default directive metadata properties
+    # Used during directive path loading to exploit default config specs.
+    def metadata_defaults  #:nodoc:
+      @@metadata_defaults_masterview
+    end
+
+    # Hash containing default directive metadata properties
+    # Used during directive path loading to exploit default config specs.
+    def metadata_defaults_extensions  #:nodoc:
+      @@metadata_defaults_extensions
+    end
+
+    # internal mechanism to provide directory/path load context during directive class loading
+    attr_reader :load_context #:nodoc:
+    def set_load_context(context_settings, check_for_conflict=true) #:nodoc:
+      if check_for_conflict && context_settings && @load_context
+        raise RuntimeError, "Directive load operation already in progress: current context=#{@load_context.inspect}, requested context=#{context_settings.inspect}"
+      end
+      @load_context = context_settings
+    end
+
+    def initialize()
       @loaded_classes = []
+      set_load_context( nil )
       clear_directive_maps()
+      #STDOUT.puts "\n###Created DirectiveRegistry=#{self.object_id}"
+      #STDOUT.puts "...loaded_classes=#{self.loaded_classes.inspect}"
+      #STDOUT.puts "...load_context=#{self.load_context.inspect}"
+    end
+
+    protected
+    def clear_directive_maps() #:nodoc:
+      @directive_namespaces = []
+      @directive_classes = {} # map fully qualified directive attr name to directive_class
+      @global_directives = [] # conditional global directives
+      @auto_directives = []  # unconditional global directives
     end
+    public  #nasty modal access specification mechanism
 
     # Register a directive implementation.
     # 
     # A directive is ordinarily a subclass of MasterView::DirectiveBase.
     # 
-    #--
-    #TODO: A directive implementation must support the following services:....
-    #++
-    # 
     def register_directive(directive_class)
-      #TODO: ensure that the directive impl supports required prototcol (i/f check...)?
+      # harden the DirectiveMetadata by filling in unspecified values from defaults
+      #assert directive_class.ancestors.include? DirectiveMetadata
+      ##AARGH: can't do this yet, the timing is premature [DJL 06-Oct-2006]
+      #PUNT: md_defaults = load_context.nil? ? metadata_defaults_extensions : load_context[:metadata_defaults]
+      #PUNT: directive_class.harden_metadata( md_defaults )
       @loaded_classes << directive_class
+      ##DEBUG##
+      if TRACE_MD_HARDENING_SUBJECT and directive_class.name == TRACE_MD_HARDENING_SUBJECT
+        STDOUT.puts "\nREGISTERED DIRECTIVE #{directive_class.name}"
+        STDOUT.puts "...TOO SOON TO HARDEN METADATA"
+        STDOUT.puts "...#{directive_class.metadata_values.object_id}: #{directive_class.metadata_values.inspect}\n"
+      end
+      ##DEBUG##
     end
 
     # Answer the (base) names of the loaded directive classes.
@@ -47,109 +168,178 @@ module MasterView
       dc.name.split(':').last
     end
 
-    # Answer the attribute name implemented by a directive class
-    def directive_attr_name( dc )
-      dc.respond_to?(:attr_name) ? dc.attr_name : simple_class_name(dc).downcase_first_letter
-    end
-
-    # Answer the fully qualified name of the attribute implemented by a directive class.
-    # attr_qname ::= <ns_name>:<attr_name>
-    def directive_full_attr_name( dc, mv_ns )
-      (dc.respond_to? :full_attr_name) ? dc.full_attr_name(mv_ns) : build_full_attribute_name(mv_ns, dc)
-    end
-
-    # this method is invoked to build the full attribute name (the attribute which will be watched for in 
-    # html attibutes. It concatenates the namespace prefix to the class name after first removing any module
-    # prefixes and then downcasing the first letter
-    def build_full_attribute_name(mv_ns, dc) #:nodoc:
-      #ISSUE: need to allow directives to control their name space
-      mv_ns + simple_class_name(dc).downcase_first_letter
-    end
-
     # Ensure that all directives on the load path are loaded.
     # Build the directive processing tables used by the template parser.
     # 
-    def process_directives_load_path( directive_paths, mv_ns=nil )
-      load_directives( directive_paths )
-      build_directive_maps( mv_ns )
+    def process_directives_load_path( load_path=nil )
+      load_path = MasterView::DirectiveLoadPath.current if load_path.nil?
+      load_directives( load_path )
+      build_directive_maps
     end
 
     # Ensure that all directives on the load path are loaded.
     # 
     # require {directives_dir}/foo_directive.rb
-    def load_directives( directive_paths=nil ) #:nodoc:
-      directive_paths = MasterView::DefaultDirectiveLoadPaths if directive_paths.nil?
-      directive_paths.each do | dir |
-        # MV::Initializer now handles bad dir path entries, but leave old checks for now [DJL 04-Jul-2006]
-        next if dir.nil?
-        if File.directory?(dir)
-          Dir.open( dir ).each { |fn| require "#{dir}/#{fn}" if fn =~ /[.]rb$/ }
+    def load_directives( load_path=nil ) #:nodoc:
+      load_path = MasterView::DirectiveLoadPath.current if load_path.nil?
+      STDOUT.puts "\n-------- LOAD DIRECTIVES ON PATH -------" if DEBUG_TRACE_LOADING
+      load_path.each do | dpe |
+        STDOUT.puts "DIRECTORY PATH ENTRY: #{dpe.inspect}" if DEBUG_TRACE_LOADING
+        if dpe.exists?
+          self.load_from_directive_path_entry( dpe )
         else
-          #raise InvalidPathError.new('Directive load path dir does not exist:'+dir) unless File.directory? dir
-          Log.error "Directive load path dir does not exist: '#{dir}'" if MasterView.const_defined?(:Log)  #backstop for test case startup
+          #raise InvalidPathError.new('Directive load path dir does not exist:'+dir_path)
+          Log.error "Directive load path dir does not exist: '#{dpe.dir_path}'" if MasterView.const_defined?(:Log)  #backstop for test case startup
         end        
       end
-      clear_directive_maps()  # ensure we take a clean point of view on the matter at hand
+      clear_directive_maps()  # ensure we take a clean point of view on whatever just got loaded
+      STDOUT.puts "------ END LOAD DIRECTIVES ------" if DEBUG_TRACE_LOADING
+    end
+
+    # Load a specific directive implementation class
+    # 
+    # Mainly provided for use by unit tests
+    def load_directive_file(directive_file_path)
+      dir_path = File.dirname(directive_file_path)
+      dpe = MasterView::DirectiveLoadPath::PathEntry.new(dir_path)
+      load_from_directive_path_entry( dpe, directive_file_path )
     end
 
+    def load_from_directive_path_entry(dpe, directive_file_path=nil) #:nodoc:
+      dir_md_specs = dpe.load_metadata_specs # :create_if_not_defined => true
+      is_mv_directives_dir = dir_md_specs.fetch(:use_masterview_namespace, false)
+      app_md_defaults = is_mv_directives_dir ? metadata_defaults : metadata_defaults_extensions
+      md_defaults = MasterView::DirectiveLoadPath.compute_md_defaults(
+                            app_md_defaults, 
+                            dir_md_specs[:default], 
+                            dpe.metadata_defaults )
+      begin
+        dir_load_context = { :metadata_defaults => md_defaults, }
+        set_load_context( dir_load_context )
+        if directive_file_path
+          # load specific file from a directive path entry directory
+          dir_load_context[:directive_file] = directive_file_path
+          load_single_directive_file(directive_file_path, md_defaults) #WAS: require directive_file_path
+        else
+          # load all directives in the directory
+          dir_path = dpe.dir_path
+          #??Log.debug { "Loading directives from #{dir_path} with metadata defaults #{md_defaults.inspect}" }
+          #??load_context[:synonyms] = dir_md_specs.fetch(:synonyms, {})??
+          #??files_to_ignore = dir_md_specs.fetch(:ignore, []).collect { |fn| fn.ends_with?('.rb') ? fn : "#{fn}.rb" }
+          Dir.entries( dir_path ).each { |fn| 
+            # we assume all .rb files in a directives dir are directive impls
+            if fn =~ /[.]rb$/  #?? && ! files_to_ignore.include?(fn)
+              directive_file_path = "#{dir_path}/#{fn}"
+              dir_load_context[:directive_file] = directive_file_path
+              #??@load_context[:directive_synonyms] = dir_synonyms_specs.fetch(fn, [])??
+              load_single_directive_file(directive_file_path, md_defaults) #WAS: require directive_file_path
+            end
+          }
+        end
+      ensure
+        set_load_context( nil )
+      end
+    end
+
+    protected
+    # we can't to this in register_directive as desired because
+    # the class defn hasn't been processed yet at that point, it seems.
+    def load_single_directive_file(directive_file_path, md_defaults)
+      last_class_loaded = @loaded_classes.last
+      require directive_file_path
+      if @loaded_classes.last != last_class_loaded
+        directive_class = @loaded_classes.last
+        directive_class.harden_metadata( md_defaults )
+        ##DEBUG##
+        if TRACE_MD_HARDENING_SUBJECT and directive_class.name == TRACE_MD_HARDENING_SUBJECT
+          STDOUT.puts "\nFINISHED LOADING DIRECTIVE #{directive_class.name}"
+          STDOUT.puts "...SHOULD HAVE HARDENED METADATA NOW:"
+          STDOUT.puts "...#{directive_class.metadata_values.object_id}: #{directive_class.metadata_values.inspect}\n"
+          STDOUT.puts ""
+        end
+        ##DEBUG##
+      end
+    end
+    public  #nasty modal access specification mechanism
+
     # Build the directive processing tables used by the template parser.
-    def build_directive_maps( mv_ns=nil )  #:nodoc:
+    def build_directive_maps()  #:nodoc:
 
-      mv_ns = MasterView::NamespacePrefix if mv_ns.nil?
       clear_directive_maps()  # ensure we take a clean point of view on the matter at hand
 
       Log.debug { 'directive plugins loaded:' + loaded_class_names.inspect }  if MasterView.const_defined?(:Log)  #backstop for test case startup
       loaded_classes.each do |dc|
-        dc.on_load if dc.respond_to?(:on_load)
-        attr_qname = directive_full_attr_name( dc, mv_ns )
-        qname_parts = attr_qname.split(':')
-        raise NameError, "Directive qname requires namespace: '#{attr_qname} - #{dc.name}" if qname_parts.length != 2
-        ns_name, attr_name = qname_parts
+        dc.on_load if dc.respond_to?(:on_load)  #ISSUE: needs review (timing, intent) [DJL 08-Oct-2006]
+        attr_qname = dc.attribute_qname
+        ns_name = dc.namespace_name
+        raise NameError, "Directive qname requires namespace: '#{attr_qname} - #{dc.name}" if ns_name.nil? || ns_name.strip().empty?
+        if DEBUG_BUILTIN_DIRECTIVE_REGISTRATION and dc.name.starts_with?('MasterView::Directives::')
+          if ns_name != 'mv'  #! attr_qname.starts_with(MasterView.mv_namespace_prefix)
+            STDOUT.puts "****BUILTIN DIRECTIVE NAMESPACE PROBLEM: #{dc.name} qname='#{attr_qname}'"
+            raise RuntimeError, "BUILTIN DIRECTIVE NS PROBLEM: #{dc.name} qname='#{attr_qname}"
+          end
+        end
         @directive_namespaces << ns_name if ! @directive_namespaces.include?( ns_name )
         @directive_classes[attr_qname] = dc
-        ###WHAT IS THIS NOTION of auto/global directive???  currently used (only) by inline_erb_directive
-        dc_instance = dc.new(nil)
-        @auto_directives << dc if dc_instance.respond_to?(:global_directive?) && dc_instance.global_directive? 
+        # global directives can be automatically attached to all elements (e.g., generated comments)
+        # or conditionally attached (e.g., a directive that wants to glom onto all elements of a specific type)
+        dc_global_spec = dc.metadata_values.fetch(:global_directive?, false)
+        if dc_global_spec == true  # unconditional global directive - applied to all elements
+          @auto_directives << dc
+        elsif dc_global_spec  # conditional global directive - applied when match condition satisfied
+          @global_directives << dc
+        end
       end
-      Log.debug { 'directives='+@directive_classes.keys().sort!().inspect }  if MasterView.const_defined?(:Log)  #backstop for test case startup
-      Log.debug { 'auto_directives='+@auto_directives.inspect }  if MasterView.const_defined?(:Log)  #backstop for test case startup
 
+      if MasterView.const_defined?(:Log)  #backstop for test case startup
+        Log.debug { "directives=#{@directive_classes.keys().sort!().inspect}" }
+        Log.debug { "global_directives=#{@global_directives.inspect}" }
+        Log.debug { "auto_directives=#{@auto_directives.inspect}" }
+      end
     end
 
     # Construct directive processors needed to handle the 
     # attributes defined on a template document element.
     # 
     # Constructs processors for all global directives
-    # and for any directive attributes.
+    # and for any directive attributes defined on the element.
     # 
+    # Removes all directive attributes from the element's attributes.
     # 
-    def construct_directive_processors( attributes )
+    def construct_directive_processors( tag_name, element_attrs )
       directive_processors = []
       # always instantiate global directive handlers
       @auto_directives.each do | dc |
         directive_processors << dc.new(nil)
       end
+      # conditionally instantiate global directives which are interested in this element
+      @global_directives.each do | dc |
+        attr_value = dc.metadata_values[:global_directive?].call( tag_name, element_attrs )
+        if attr_value
+          directive_processors << dc.new(attr_value)
+        end
+      end
       # instantiate the directive processor on the attribute value if its attr present
-      # remove the MV attribute from the document so that it's only effect is from the processor action
+      # remove the MV attribute from the document so that its only effect is from the processor action
       @directive_classes.each do | attr_qname, dc |
-        directive_processors << dc.new(attributes.delete(attr_qname)) if attributes[attr_qname]
+        directive_attr_value = element_attrs[attr_qname]
+        if directive_attr_value
+          # convert the directive into a processing handler for this element
+          element_attrs.delete(attr_qname)
+          directive_processors << dc.new(directive_attr_value)
+        end
       end
       directive_processors
     end
 
-    protected
-    def clear_directive_maps() #:nodoc:
-      @directive_namespaces = []
-      @directive_classes = {} #map fully qualified directive attr name to directive_class
-      @auto_directives = []
-    end
+    # class initialization
+    self.current = self.new()
+    #STDOUT.puts "INITIALIZED DirectiveRegistry.current=#{DirectiveRegistry.current.object_id}"  ##DEBUG##
+    #STDOUT.puts "...DirectiveRegistry.current=#{DirectiveRegistry.current.inspect}"  ##DEBUG##  
+    #STDOUT.puts "END DirectiveRegistry definition\n"  ##DEBUG##
 
   end
 
-  # The DirectivesRegistry manages the loaded directives available 
-  # for processing template markup
-  DirectivesRegistry = DirectiveRegistry.new()
-
   # Register a directive implementation.
   # 
   # Registration is handled automatically for directives
@@ -158,12 +348,12 @@ module MasterView
   # module in a directive implementation class.
   # 
   # Directive registration ordinarily occurs during MasterView
-  # initialization, when directive classes on the configured
-  # <code>directive_paths</code> directories are automatically
+  # initialization, when directive classes from the configured
+  # <code>directive_load_path</code> directories are automatically
   # loaded and registered with the template engine.
   # 
   def self.register_directive(directive_class)
-      DirectivesRegistry.register_directive(directive_class)
+      DirectiveRegistry.current.register_directive(directive_class)
   end
 
-end
+end

data/lib/masterview/directives/.metadata

@@ -0,0 +1,16 @@
+# MasterView directive metadata specifications
+# Built-in MasterView directives
+
+# default metadata values for directives loaded from this directory
+default:
+  namespace: mv
+  description: Built-in MasterView directive
+
+# optionally specify any .rb files in this directory to ignore
+#ignore: []
+
+# optionally specify synonyms to register directives
+# Mainly intended to provide backwards compat (hopefully for short-term transition only...)
+# Synonym spec ::= [ <directive attribute name>, <synonym> [, <synonym]...
+#synonyms:
+#    - [ foo, oldfoo ]

data/lib/masterview/directives/attr.rb

@@ -1,27 +1,28 @@
 module MasterView
   module Directives
+
     # takes the attr_value and parses it as a hash :foo => 'bar', :baz => 'cat'
     # it sets/overrides the tag's attribute values for each value.
     # To use erb output simply wrap the content in #{ foo } for example :foo => #{h product.name}
+    # 
     class Attr < MasterView::DirectiveBase
       # substitution to make it easy to parse erb in attr
       SubstForErb = '#'+InlineErbStart+'= \1 '+InlineErbEnd+'#'
 
-      def priority
-        DirectivePriorities::MediumLow
-      end
-      
-      def stag(dcs)
-        
+      metadata :priority => 'MediumLow',
+        :category => 'general',
+        :description => 'Replaces attribute value(s) on an element with the value of an expression'
+
+      event :stag do
         attr_value.gsub!( /#\{([^}]*)\}/, SubstForErb ) #taking #{h product.name} and changing to #{{{= h product.name}}}# for easy parsing
         arr = attr_value.scan( /:(\w+)\s*=>\s*(['"#])([^,\2]*)\2,?/  )
         arr.each do |scn|
           n = scn[0]
           v = scn[2]
-          dcs.context[:tag].attributes[n] = v
+          element_attrs[n] = v
         end
-        dcs.render
       end
+
     end
   end
 end

data/lib/masterview/directives/block.rb

@@ -1,27 +1,24 @@
 module MasterView
   module Directives
 
-    #outputs a block around the text tags, if left bracket count is higher than right
-    #assume that the end is a right bracket otherwise use end
+    # outputs a block around the text tags, if left bracket count is higher than right
+    # assume that the end is a right bracket otherwise use end
+    # 
     class Block < MasterView::DirectiveBase
-      def priority
-        DirectivePriorities::MediumHigh
-      end
 
-      def stag(directive_call_stack)
+      metadata :priority => 'MediumHigh',
+        :category => 'erb',
+        :description => 'Expands to the equivalent rhtml (erb) block code around the element'
+
+      event :before_stag do
         count_left_brackets = attr_value.scan( /\{/ ).size
         count_right_brackets = attr_value.scan( /\}/ ).size
         @end_block = (count_left_brackets > count_right_brackets) ? '}' : 'end'
-
-        ret = []
-        ret << erb(attr_value)
-        ret << directive_call_stack.render
+        render erb_eval(attr_value)
       end
 
-      def etag(directive_call_stack)
-        ret = []
-        ret << directive_call_stack.render
-        ret << erb(@end_block)
+      event :after_etag do
+        render erb_eval(@end_block)
       end
 
     end

data/lib/masterview/directives/check_box.rb

@@ -3,27 +3,22 @@ module MasterView
 
     # create check_box helper, quoting object and method if necessary
     # merging in any html options specified
-    class Check_box < MasterView::DirectiveBase
-      def stag(dcs)
-        #eat
-      end
-
-      def etag(dcs)
-        args = parse_attr_value
-        obj = args[0]
-        method = args[1]
-        options_and_on_off = args[2..-1].join(', ')
+    # 
+    class CheckBox < MasterView::DirectiveBase
 
-        obj = quote_if(obj)
-        method = quote_if(method)
+      metadata :priority => :default,
+        :category => 'form',
+        :description => 'Replaces the element with a Rails check_box form helper',
+        :element_usage => 'input'
 
-        options_and_on_off = merge_into_embedded_hash(options_and_on_off, 0, common_html_options(attrs_lck))
+      attr_arg :object_name, :quote => true
+      attr_arg :method, :quote => true
+      attr_arg :options, :default => {}, :append_element_attrs => [:common_html]
+      attr_arg :checked_value, :default => "'1'"
+      attr_arg :unchecked_value
 
-        a = []
-        a << 'check_box '+ obj
-        a << method
-        a << options_and_on_off if options_and_on_off && !options_and_on_off.strip.empty?
-        erb_content(a.join(', '))
+      event :element do
+        render erb_content( 'check_box', :object_name, :method, :options, :checked_value, :unchecked_value )
       end
 
     end

data/lib/masterview/directives/collection_select.rb

@@ -5,38 +5,24 @@ module MasterView
     # html options specfied on element into any html options in attr_value
     # attr_value syntax:
     # object, method, collection, value_method, text_method, options = {}, html_options = {}
-    class Collection_select < MasterView::DirectiveBase
-      def stag(dcs)
-        #eat
-      end
-
-      def etag(dcs)
-        args = parse_attr_value
-        obj = quote_if(args[0])
-        method = quote_if(args[1])
-        collection = quote_if(args[2])
-        value_method = quote_if(args[3])
-        text_method = quote_if(args[4])
-        options = args[5]
-        html_options = args[6]
+    # 
+    class CollectionSelect < MasterView::DirectiveBase
 
-        opt = {}
-        opt[:size] = attrs_lck['size'].to_i if attrs_lck['size']
-        opt.merge! common_html_options(attrs_lck)
-        html_options = merge_into_embedded_hash(html_options, 0, opt)
-        options = '{}' if options.to_s.empty? && !html_options.to_s.empty? # if we have html_options but no options, still need empty hash
+      metadata :priority => :default,
+        :category => 'form',
+        :description => 'Replaces the element with a Rails collection_select form helper.',
+        :element_usage => 'select'
 
-        a = []
-        a << 'collection_select '+ obj
-        a << method
-        a << collection
-        a << value_method
-        a << text_method
-        a << options unless options.to_s.strip.empty?
-        a << html_options unless html_options.to_s.strip.empty?
+      attr_arg :object_name, :quote => true
+      attr_arg :method, :quote => true
+      attr_arg :collection , :quote => true
+      attr_arg :value_method, :quote => true
+      attr_arg :text_method, :quote => true
+      attr_arg :options, :default => {}
+      attr_arg :html_options, :append_element_attrs => [:common_html]
 
-        self.content = ''
-        erb_content(a.join(', '))
+      event :element do
+        render erb_content( 'collection_select', :object_name, :method, :collection, :value_method, :text_method, :options, :html_options)
       end
 
     end

data/lib/masterview/directives/content.rb

@@ -1,10 +1,16 @@
 module MasterView
   module Directives
     class Content < MasterView::DirectiveBase
-      def etag(dcs)
-        self.content = erb_content(attr_value)
-        dcs.render
+
+      metadata :priority => :default,
+        :category => 'general',
+        :description => 'Replaces the content of the element with the value of the expression'
+
+      # replace the content of the element with <%= attr_value %>
+      event :content do
+        render erb_content( attr_value )
       end
+
     end
   end
 end

data/lib/masterview/directives/else.rb

@@ -1,23 +1,25 @@
 module MasterView
   module Directives
-    #outputs an else/end block around the text tags removing previous end tag (from if/elsif)
+
+    # outputs an else/end block around the text tags removing previous end tag (from if/elsif)
+    #
     class Else < MasterView::DirectiveBase
-      def priority
-        DirectivePriorities::High
-      end
 
-      def stag(directive_call_stack)
+      metadata :priority => 'High',
+        :category => 'erb',
+        :description => 'Used in conjunction with the mv:if and mv:elsif directives to allow you to create if... elsif... else... end blocks'
+
+      # remove the last <% end -%> from the parent tag's content and add a <% else -%> instead.
+      # This is a continuation of previous if or elsif statement.
+      event :before_stag do
         tag = @directive_call_stack.context[:tag]
-        delete_last_in_parent(tag, erb('end') )
-        ret = []
-        ret << erb('else')
-        ret << directive_call_stack.render
+        delete_last_in_parent(tag, erb_eval('end') )
+        render erb_eval( 'else' )
       end
 
-      def etag(directive_call_stack)
-        ret = []
-        ret << directive_call_stack.render
-        ret << erb('end')
+      # output <% end -%>
+      event :after_etag do
+        render erb_eval( 'end' )
       end
 
     end