dryml 1.1.0.pre0

data/lib/dryml/template_handler.rb

@@ -0,0 +1,187 @@
+module Dryml
+
+  class TemplateHandler < ActionView::TemplateHandler
+    
+    def compile(*args)
+      # Ignore - we handle compilation ourselves
+    end
+    
+    # Pre Rails 2.2
+    def render(template)
+      renderer = Dryml.page_renderer_for_template(@view, template.locals.keys, template)
+      this = @view.instance_variable_set("@this", @view.controller.send(:dryml_context) || template.locals[:this])
+      s = renderer.render_page(this, template.locals)
+      # Important to strip whitespace, or the browser hangs around for ages (FF2)
+      s.strip
+    end
+    
+    def render_for_rails22(template, view, local_assigns)
+      renderer = Dryml.page_renderer_for_template(view, local_assigns.keys, template)
+      this = view.controller.send(:dryml_context) || local_assigns[:this]
+      @view._?.instance_variable_set("@this", this)
+      s = renderer.render_page(this, local_assigns)
+
+      # Important to strip whitespace, or the browser hangs around for ages (FF2)
+      s.strip
+    end
+
+  end
+
+end
+
+module ActionController
+
+  class Base
+
+    def dryml_context
+      @this
+    end
+
+    def dryml_fallback_tag(tag_name)
+      @dryml_fallback_tag = tag_name
+    end
+
+
+    def call_dryml_tag(tag, options={})
+      @template.send(:_evaluate_assigns_and_ivars)
+
+      # TODO: Figure out what this bit is all about :-)
+      if options[:with]
+        @this = options[:with] unless options[:field]
+      else
+        options[:with] = dryml_context
+      end
+
+      Dryml.render_tag(@template, tag, options)
+    end
+
+
+    # TODO: This is namespace polution, should be called render_dryml_tag
+    def render_tag(tag, attributes={}, options={})
+      text = call_dryml_tag(tag, attributes)
+      text && render({:text => text, :layout => false }.merge(options))
+    end
+    
+    # DRYML fallback tags -- monkey patch this method to attempt to render a tag if there's no template
+    def render_for_file_with_dryml(template, status = nil, layout = nil, locals = {})
+      # in rails 2.2, "template" is actually "template_path"
+      
+      # if we're passed a MissingTemplateWrapper, see if there's a
+      # dryml tag that will render the page
+      if template.respond_to? :original_template_path
+        # this is the Rails 2.3 path
+        tag_name = @dryml_fallback_tag || "#{File.basename(template.original_template_path).dasherize}-page"
+        
+        text = call_dryml_tag(tag_name)
+        if text
+          return render_for_text(text, status)
+        else
+          template.raise_wrapped_exception
+        end
+      else
+        begin
+          result = render_for_file_without_dryml(template, status, layout, locals)
+        rescue ActionView::MissingTemplate => ex
+          # this is the Rails 2.2 path
+          tag_name = @dryml_fallback_tag || "#{File.basename(template).dasherize}-page"
+          
+          text = call_dryml_tag(tag_name)
+          if text
+            return render_for_text(text, status)
+          else
+            raise ex
+          end
+        end
+      end
+    end
+    alias_method_chain :render_for_file, :dryml
+      
+  end
+end
+
+class ActionView::Template
+  
+  def render_with_dryml(view, local_assigns = {})
+    if handler == Dryml::TemplateHandler
+      render_dryml(view, local_assigns)
+    else
+      render_without_dryml(view, local_assigns)
+    end
+  end
+  alias_method_chain :render, :dryml
+  
+  # We've had to copy a bunch of logic from Renderable#render, because we need to prevent Rails
+  # from trying to compile our template. DRYML templates are each compiled as a class, not just a method,
+  # so the support for compiling templates that Rails provides is innadequate.
+  def render_dryml(view, local_assigns = {})
+    if view.instance_variable_defined?(:@_render_stack)
+      # Rails 2.2
+      stack = view.instance_variable_get(:@_render_stack)
+      stack.push(self)
+ 
+      # This is only used for TestResponse to set rendered_template
+      unless is_a?(ActionView::InlineTemplate) || view.instance_variable_get(:@_first_render)
+        view.instance_variable_set(:@_first_render, self)
+      end
+
+      view.send(:_evaluate_assigns_and_ivars)
+      view.send(:_set_controller_content_type, mime_type) if respond_to?(:mime_type)
+ 
+      result = Dryml::TemplateHandler.new.render_for_rails22(self, view, local_assigns)
+ 
+      stack.pop
+      result
+    else
+      # Rails 2.3      
+      compile(local_assigns)
+
+      view.with_template self do
+        view.send(:_evaluate_assigns_and_ivars)
+        view.send(:_set_controller_content_type, mime_type) if respond_to?(:mime_type)
+        
+        Dryml::TemplateHandler.new.render_for_rails22(self, view, local_assigns)      
+      end
+    end
+  end
+  
+end
+
+# this is only used in Rails 2.3
+class MissingTemplateWrapper
+  attr_reader :original_template_path
+  
+  def initialize(exception, path)
+    @exception = exception
+    @original_template_path = path
+  end
+
+  def method_missing(*args)
+    raise @exception
+  end
+
+  def render
+    raise @exception
+  end
+end
+  
+    
+module ActionView
+  class PathSet < Array
+    # this is only used by Rails 2.3
+    def find_template_with_dryml(original_template_path, format = nil, html_fallback = true)
+      begin
+        find_template_without_dryml(original_template_path, format, html_fallback)
+      rescue ActionView::MissingTemplate => ex
+        # instead of throwing the exception right away, hand back a
+        # time bomb instead.  It'll blow if mishandled...
+        return MissingTemplateWrapper.new(ex, original_template_path)
+      end
+    end
+
+    if method_defined? "find_template"
+      # only rails 2.3 has this function
+      alias_method_chain :find_template, :dryml
+    end
+  end
+end
+        

data/lib/dryml.rb

@@ -0,0 +1,291 @@
+# The Don't Repeat Yourself Markup Language
+#
+# Author::    Tom Locke (tom@tomlocke.com)
+# Copyright:: Copyright (c) 2008
+# License::   Distributes under the same terms as Ruby
+
+
+
+# gem dependencies
+require 'hobosupport'
+require 'action_pack'
+require 'active_record' if ActionPack::VERSION::MAJOR==2 && ActionPack::VERSION::MINOR==2
+
+ActiveSupport::Dependencies.load_paths |= [ File.dirname(__FILE__)] if ActiveSupport.const_defined? :Dependencies
+
+# Hobo can be installed in /vendor/hobo, /vendor/plugins/hobo, vendor/plugins/hobo/hobo, etc.
+::DRYML_ROOT = File.expand_path(File.dirname(__FILE__) + "/..")
+
+# The Don't Repeat Yourself Markup Language
+module Dryml
+
+    VERSION = "1.1.0.pre0"
+
+    class DrymlSyntaxError < RuntimeError; end
+      
+    class DrymlException < Exception
+      def initialize(message, path=nil, line_num=nil)
+        if path && line_num
+          super(message + " -- at #{path}:#{line_num}")
+        else
+          super(message)
+        end
+      end
+    end
+
+    TagDef = Struct.new "TagDef", :name, :attrs, :proc
+
+    RESERVED_WORDS = %w{if for while do class else elsif unless case when module in}
+
+    EMPTY_PAGE = "[tag-page]"
+
+    APPLICATION_TAGLIB = { :src => "taglibs/application" }
+    CORE_TAGLIB        = { :src => "core", :plugin => "dryml" }
+
+    DEFAULT_IMPORTS = defined?(ApplicationHelper) ? [ApplicationHelper] : []
+
+    @renderer_classes = {}
+    @tag_page_renderer_classes = {}
+
+    extend self
+
+    attr_accessor :last_if
+    
+    def enable(generator_directories=[], output_directory=".")
+      ActionView::Template.register_template_handler("dryml", Dryml::TemplateHandler)
+      if ActionView::Template.respond_to? :exempt_from_layout
+        ActionView::Template.exempt_from_layout('dryml')
+      elsif
+        ActionView::Base.exempt_from_layout('dryml')
+      end
+      DrymlGenerator.enable(generator_directories, output_directory)
+    end
+    
+    
+    def precompile_taglibs
+      Dir.chdir(RAILS_ROOT) do
+        taglibs = Dir["vendor/plugins/**/taglibs/**/*.dryml"] + Dir["app/views/taglibs/**/*.dryml"]
+        taglibs.each do |f|
+          Dryml::Taglib.get(:template_dir => File.dirname(f), :src => File.basename(f).remove(".dryml"))
+        end
+      end
+    end
+    
+
+    def clear_cache
+      @renderer_classes = {}
+      @tag_page_renderer_classes = {}
+    end
+
+    def render_tag(view, tag, options={})
+      renderer = empty_page_renderer(view)
+      renderer.render_tag(tag, options)
+    end
+
+
+    def empty_page_renderer(view)
+      controller_name = view.controller.class.name.underscore.sub(/_controller$/, "")
+      page_renderer(view, [], "#{controller_name}/#{EMPTY_PAGE}")
+    end
+
+
+    def page_renderer_for_template(view, local_names, template)
+      page_renderer(view, local_names, template.path_without_extension, template.filename)
+    end
+
+
+    def page_renderer(view, local_names=[], page=nil, filename=nil)
+      if RAILS_ENV == "development"
+        clear_cache
+        Taglib.clear_cache
+      end
+
+      prepare_view!(view)
+      included_taglibs = ([APPLICATION_TAGLIB, subsite_taglib(page)] + controller_taglibs(view.controller.class)).compact
+
+      if page.ends_with?(EMPTY_PAGE)
+        # DELETE ME: controller_class = controller_class_for(page)
+        controller_class = view.controller.class
+        @tag_page_renderer_classes[controller_class.name] ||=
+          make_renderer_class("", page, local_names, DEFAULT_IMPORTS, included_taglibs)
+        @tag_page_renderer_classes[controller_class.name].new(page, view)
+      else        
+        filename ||= if view.view_paths.respond_to? :find_template
+                       # Rails 2.3
+                       view.view_paths.find_template(page + ".dryml").filename
+                     else
+                       # Rails 2.2
+                       view._pick_template(page + ".dryml").filename
+                     end
+        mtime = File.mtime(filename)
+        renderer_class = @renderer_classes[page]
+
+        # do we need to recompile?
+        if (!renderer_class ||                                          # nothing cached?
+            (local_names - renderer_class.compiled_local_names).any? || # any new local names?
+            renderer_class.load_time < mtime)                           # cache out of date?
+          renderer_class = make_renderer_class(File.read(filename), filename, local_names,
+                                               DEFAULT_IMPORTS, included_taglibs)
+          renderer_class.load_time = mtime
+          @renderer_classes[page] = renderer_class
+        end
+        renderer_class.new(page, view)
+      end
+    end
+
+
+    # TODO: Delete this - not needed (use view.controller.class)
+    def controller_class_for(page)
+      controller, view = Controller.controller_and_view_for(page)
+      "#{controller.camelize}Controller".constantize
+    end
+
+
+    def controller_taglibs(controller_class)
+      controller_class.try.included_taglibs || []
+    end
+
+
+    def subsite_taglib(page)
+      parts = page.split("/")
+      subsite = parts.length >= 3 ? parts[0..-3].join('_') : "front"
+      src = "taglibs/#{subsite}_site"
+      { :src => src } if Object.const_defined?(:RAILS_ROOT) && File.exists?("#{RAILS_ROOT}/app/views/#{src}.dryml")
+    end
+
+    def get_field(object, field)
+      return nil if object.nil?
+      field_str = field.to_s
+      begin
+        return object.send(field_str)
+      rescue NoMethodError => ex
+        if field_str =~ /^\d+$/
+          return object[field.to_i]
+        else
+          return object[field]
+        end
+      end
+    end
+
+
+    def get_field_path(object, path)
+      path = if path.is_a? String
+               path.split('.')
+             else
+               Array(path)
+             end
+
+      parent = nil
+      path.each do |field|
+        return nil if object.nil?
+        parent = object
+        object = get_field(parent, field)
+      end
+      [parent, path.last, object]
+    end    
+
+
+    def prepare_view!(view)
+      # Not sure why this isn't done for me...
+      # There's probably a button to press round here somewhere
+      for var in %w(@flash @cookies @action_name @_session @_request @request_origin
+                    @template @request @ignore_missing_templates @_headers @variables_added
+                    @_flash @response @template_class
+                    @_cookies @before_filter_chain_aborted @url
+                    @_response @template_root @headers @_params @params @session)
+        unless @view.instance_variables.include?(var)
+          view.instance_variable_set(var, view.controller.instance_variable_get(var))
+        end
+      end
+    end
+
+    # create and compile a renderer class (AKA Dryml::Template::Environment)
+    #
+    # template_src:: the DRYML source
+    # template_path:: the filename of the source.  This is used for
+    #                 caching
+    # locals:: local variables.
+    # imports:: A list of helper modules to import.  For example, Hobo
+    #           uses [Hobo::HoboHelper, Hobo::Translations,
+    #           ApplicationHelper] 
+    # included_taglibs:: A list of Taglibs to include. { :src =>
+    #                    "core", :plugin => "dryml" } is automatically
+    #                    added to this list.
+    #
+    def make_renderer_class(template_src, template_path, locals=[], imports=[], included_taglibs=[])
+      renderer_class = Class.new(TemplateEnvironment)
+      compile_renderer_class(renderer_class, template_src, template_path, locals, imports, included_taglibs)
+      renderer_class
+    end
+
+
+    def compile_renderer_class(renderer_class, template_src, template_path, locals, imports, included_taglibs=[])
+      template = Dryml::Template.new(template_src, renderer_class, template_path)
+      imports.each {|m| template.import_module(m)}
+
+      taglibs = [CORE_TAGLIB] + included_taglibs
+
+      # the sum of all the names we've seen so far - eventually we'll be ready for all of 'em
+      all_local_names = renderer_class.compiled_local_names | locals
+
+      template.compile(all_local_names, taglibs)
+    end
+
+
+    def unreserve(word)
+      word = word.to_s
+      if RESERVED_WORDS.include?(word)
+        word + "_"
+      else
+        word
+      end
+    end
+
+
+    def static_tags
+      @static_tags ||= begin
+                         path = if Object.const_defined?(:RAILS_ROOT) && FileTest.exists?("#{RAILS_ROOT}/config/dryml_static_tags.txt")
+                                    "#{RAILS_ROOT}/config/dryml_static_tags.txt"
+                                else
+                                    File.join(File.dirname(__FILE__), "dryml/static_tags")
+                                end
+                         File.readlines(path).*.chop
+                       end
+    end
+
+    attr_writer :static_tags
+
+    # Helper function for use outside Hobo/Rails
+    #
+    # Pass the template context in locals[:this]
+    #
+    # This function caches.  If the mtime of template_path is older
+    # than the last compilation time, the cached version will be
+    # used.  If no template_path is given, template_src is used as the
+    # key to the cache.
+    #
+    # If a local variable is not present when the template is
+    # compiled, it will be ignored when the template is used.  In
+    # other words, the variable values may change, but the names may
+    # not.
+    #
+    # included_taglibs is only used during template compilation.
+    #
+    # @param [String] template_src the DRYML source
+    # @param [Hash] locals local variables.
+    # @param [String, nil] template_path the filename of the source.  
+    # @param [Array] included_taglibs A list of Taglibs to include. { :src =>
+    #                    "core", :plugin => "dryml" } is automatically
+    #                    added to this list.
+    # @param [ActionView::Base] view an ActionView instance    
+    def render(template_src, locals={}, template_path=nil, included_taglibs=[], view=nil)
+      template_path ||= template_src
+      view ||= ActionView::Base.new(ActionController::Base.view_paths, {})
+      this = locals.delete(:this) || nil
+
+      renderer_class = Dryml::Template.build_cache[template_path]._?.environment ||
+        Dryml.make_renderer_class(template_src, template_path, locals.keys)
+      renderer_class.new(template_path, view).render_page(this, locals)      
+    end
+    
+end

data/taglibs/core.dryml

@@ -0,0 +1,136 @@
+<!-- Core DRYML tags. These are included implicitly and are always available. Contains mainly control-flow tags. -->
+
+<!-- Call the tag given by the `tag` attribute. This lets you call tags dynamically based on some runtime value.
+  It's the DRYML equivalent of Ruby's `send` method.
+-->
+<def tag="call-tag" attrs="tag">
+  <%= send(tag.gsub('-', '_'), attributes, parameters) %>
+</def>
+
+
+<!-- Wrap the body in the tag specified by the `tag` attribute, iff `when` is true.
+
+Using regular DRYML conditional logic it is rather akward to conditionally wrap some tag in another tag. This tag makes it easy to do that.
+
+### Usage
+
+For example, you might want to wrap an `<img>` tag in an `<a>` tag but only under certain conditions. Say the current context has an `href` attribute that may or may not be nil. We want to wrap the img in `<a>` if `href` is not nil:
+  
+    <wrap when="&this.href.present?" tag="a" href="&this.href"><img src="&this.img_filename"/></wrap>
+{: .dryml}  
+-->
+<def tag="wrap" attrs="tag, when, parameter">
+  <% parameter ||= :default %>
+  <%= when_ ? send(tag, attributes, { parameter.to_sym => parameters[:default] }) : parameters.default %>
+</def>
+
+
+<!-- DRYML version of `render(:partial => 'my_partial')`
+
+### Usage
+
+    <partial name="my-partial" locals="&{:x => 10, :y => 20}"/>
+-->
+<def tag="partial" attrs="name, locals"><%= 
+   locals ||= {}
+   render(:partial => name, :locals => locals.merge(:this => this))
+%></def>
+
+
+<!-- Repeat a section of mark-up. The context should be a collection (anything that responds to `each`). The content of the call to `<repeat>` will be repeated for each item in the collection, and the context will be set to each item in turn.
+
+### Attributes
+
+ - join: The value of this attribute, if given, will be inserted between each of the items (e.g. `join=", "` is very common).  
+-->
+<def tag="repeat" attrs="join"><if><%= 
+  raise ArgumentError, "Cannot <repeat> on #{this.inspect}" unless this.respond_to? :each
+  context_map do
+    parameters.default
+  end.join(join)
+%></if></def>
+
+
+<!-- The 'do nothing' tag. Used to add parameters or change context without adding any markup -->
+<def tag="do"><%= parameters.default %></def>
+
+<!-- Alias of `do` -->
+<def tag="with" alias-of="do"/>
+
+<!-- DRYML's 'if' test
+
+### Usage
+
+    <if test="&current_user.administrtator?">Logged in as administrator</if>
+    <else>Logged in as normal user</else>
+    
+**IMPORTANT NOTE**: `<if>` tests for non-blank vs. blank (as defined by ActiveSuport), not true vs. false. 
+
+If you do not give the `test` attribute, uses the current context instead. This allows a nice trick like this:
+
+    <if:comments>...</if>
+    
+This has the double effect of changing the context to the `this.comments`, and only evaluating the body if there are comments (because an empty
+collection is considered blank)  
+-->
+<def tag="if" attrs="test"><%= 
+  test = all_attributes.fetch(:test, this)
+  res = (cond = !test.blank?) ? parameters.default : ""
+  Dryml.last_if = cond
+  res
+%></def>
+
+<!-- General purpose `else` clause.
+
+`<else>` works with various tags such as `<if>` and `<repeat>` (the else clause will be output if the collection was empty). It simply outputs its content if `Dryml.last_if` is false. This is pretty much a crazy hack which violates many good principles of language design, but it's very useful : )
+-->
+<def tag="else"><%= parameters.default unless Dryml.last_if %></def>
+
+
+<!-- Same behaviour as `<if>`, except the test is negated. -->
+<def tag="unless" attrs="test"><%= 
+  test = all_attributes.fetch(:test, this)     
+  res = (cond = test.blank?) ? parameters.default : ""
+  Dryml.last_if = cond
+  res
+%></def>
+
+
+<!-- nodoc. -->
+<def tag="fake-field-context" attrs="fake-field, context"><%=
+  res = ""
+  new_field_context(fake_field, context) { res << parameters.default }
+  res
+%></def>
+
+
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="html"><%= "<html#{tag_options(attributes)}>" -%><do param="default"/><%= "</html>" -%></def>
+
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="table"><%= "<table#{tag_options(attributes)}>" -%><do param="default"/><%= "</table>" -%></def>
+
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="a"><%= "<a#{tag_options(attributes)}>" -%><do param="default"/><%= "</a>" -%></def>
+
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="section"><%= "<section#{tag_options(attributes)}>" -%><do param="default"/><%= "</section>" -%></def>
+
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="header"><%= "<header#{tag_options(attributes)}>" -%><do param="default"/><%= "</header>" -%></def>
+
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="footer"><%= "<footer#{tag_options(attributes)}>" -%><do param="default"/><%= "</footer>" -%></def>
+
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="form"><%= "<form#{tag_options(attributes)}>" -%><do param="default"/><%= "</form>" -%></def>
+
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="submit"><%= "<submit#{tag_options(attributes)}>" -%><do param="default"/><%= "</submit>" -%></def>
+
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="input"><%= "<input#{tag_options(attributes)}>" -%><do param="default"/><%= "</input>" -%></def>
+
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="link"><%= "<link#{tag_options(attributes)}>" -%><do param="default"/><%= "</link>" -%></def>
+

data/test/dryml.rdoctest

@@ -0,0 +1,68 @@
+
+        >> require 'rubygems'
+        >> require 'active_support'
+        >> require 'action_view'
+        >> require 'action_controller'
+        >> $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '../../hobosupport/lib')
+        >> $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '../../dryml/lib')
+        >> require 'hobosupport'
+        >> require 'dryml'
+        >> require 'dryml/template_handler'
+        >> Dryml.enable
+
+{.hidden}
+
+        >> Dryml.render("hi")
+        => "hi"
+
+        >> Dryml.render("<%= this %>", {:this => "hello"})
+        => "hello"
+
+        >> Dryml.render(%q{<if test="&true">Hi</if><else>Bye</else>})
+        => "Hi"
+
+        >> Dryml.render(%q{<repeat with="&[1,2,3]"><%= this %> </repeat>})
+        => "1 2 3 "
+
+        >> Dryml.render(%q{<def tag="myp"><p param="default"/></def><myp>Hi</myp>})
+        => "<p>Hi</p>"
+
+        >> Dryml.render(%q{<def tag="myp"><p param="default"/></def><call-tag tag="myp">Hi</call-tag>}).strip
+        => "<p>Hi</p>"
+
+        >> Dryml.render(%q{<def tag="myp"><p param="default"/></def><wrap tag="myp" when="&true">img</wrap>}).strip
+        => "<p>img</p>"
+
+This triggers bug #452, so disabled.  FIXME.
+
+        #>> 
+         Dryml.render(%q{<def tag="myp">
+                             <p param="default"/>
+                           </def>
+                           <extend tag="myp">                             
+                             <old-myp merge>
+                               <default: replace>Hello <default: restore/></default:>
+                             </old-myp>
+                           </extend>
+                           <myp>World</myp>}).strip
+        #=> "<p>Hello World</p>"
+
+Test caching
+
+        >> template = %q{<if test="&x">Hi</if><else>Bye</else>}
+        >> t1 = Time.now
+        >> Dryml.render(template, {:x => true})
+        => "Hi"
+        >> t2 = Time.now
+        >> Dryml.render(template, {:x => false})
+        => "Bye"
+        >> t3 = Time.now
+
+        >> (t3-t2)*1.5 < (t2-t1)
+        => true
+
+Test descendent searching
+
+        >> doc = REXML::Document.new '<a><b><c><d a="b">sean</d></c></b></a>'
+        >> Dryml::Template.descendent_select(doc.root) { |el| el.attribute 'a' }.size
+        => 1