markaby 0.8.1 → 0.9.1

data/lib/markaby/builder.rb

@@ -1,5 +1,5 @@
-require 'markaby/tags'
-require 'markaby/builder_tags'
+require "markaby/tagset"
+require "markaby/builder_tags"
 
 module Markaby
   RUBY_VERSION_ID = RUBY_VERSION.split(".").join.to_i
@@ -23,30 +23,13 @@ module Markaby
   #
   class Builder
     include Markaby::BuilderTags
-
-    DEFAULT_OPTIONS = {
-      :indent                 => 0,
-      :output_helpers         => true,
-      :output_xml_instruction => true,
-      :output_meta_tag        => 'xhtml',
-      :auto_validation        => true,
-      :tagset                 => Markaby::XHTMLTransitional,
-      :root_attributes => {
-        :xmlns      => 'http://www.w3.org/1999/xhtml',
-        :'xml:lang' => 'en',
-        :lang       => 'en'
-      }
+    GENERIC_OPTIONS = {
+      indent: 0,
+      auto_validation: true
     }
 
-    HTML5_OPTIONS = {
-      :indent                 => 0,
-      :output_helpers         => true,
-      :output_xml_instruction => false,
-      :output_meta_tag        => 'html5',
-      :auto_validation        => true,
-      :tagset                 => Markaby::HTML5,
-      :root_attributes        => {}
-    }
+    HTML5_OPTIONS = HTML5.default_options.dup
+    DEFAULT_OPTIONS = GENERIC_OPTIONS.merge(HTML5_OPTIONS)
 
     @@options = DEFAULT_OPTIONS.dup
 
@@ -54,10 +37,6 @@ module Markaby
       @@options = DEFAULT_OPTIONS.dup
     end
 
-    def self.set_html5_options!
-      @@options = HTML5_OPTIONS.dup
-    end
-
     def self.set(option, value)
       @@options[option] = value
     end
@@ -66,15 +45,15 @@ module Markaby
       @@options[option]
     end
 
-    def self.ignored_helpers
-      @@ignored_helpers ||= []
-    end
+    attr_reader :tagset
 
-    def self.ignore_helpers(*helpers)
-      ignored_helpers.concat helpers
-    end
+    def tagset=(tagset)
+      @tagset = tagset
 
-    attr_accessor :output_helpers, :tagset
+      tagset.default_options.each do |k, v|
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+    end
 
     # Create a Markaby builder object.  Pass in a hash of variable assignments to
     # +assigns+ which will be available as instance variables inside tag construction
@@ -105,13 +84,11 @@ module Markaby
         instance_variable_set("@#{k}", v)
       end
 
-      if helper
-        helper.instance_variables.each do |iv|
-          instance_variable_set(iv, helper.instance_variable_get(iv))
-        end
+      helper&.instance_variables&.each do |iv|
+        instance_variable_set(iv, helper.instance_variable_get(iv))
       end
 
-      @builder = XmlMarkup.new(:indent => @indent, :target => @streams.last)
+      @builder = XmlMarkup.new(indent: @indent, target: @streams.last)
 
       text(capture(&block)) if block
     end
@@ -170,50 +147,24 @@ module Markaby
     # Create a tag named +tag+. Other than the first argument which is the tag name,
     # the arguments are the same as the tags implemented via method_missing.
     def tag!(tag, *args, &block)
-      ele_id = nil
+      attributes = {}
       if @auto_validation && @tagset
-        if !@tagset.tagset.has_key?(tag)
-          raise InvalidXhtmlError, "no element `#{tag}' for #{tagset.doctype}"
-        elsif args.last.respond_to?(:to_hash)
-          attrs = args.last.to_hash
-
-          if @tagset.forms.include?(tag) && attrs[:id]
-            attrs[:name] ||= attrs[:id]
-          end
-
-          attrs.each do |k, v|
-            atname = k.to_s.downcase.intern
-            unless k =~ /:/ or @tagset.tagset[tag].include? atname
-              raise InvalidXhtmlError, "no attribute `#{k}' on #{tag} elements"
-            end
-            if atname == :id
-              ele_id = v.to_s
-              if @used_ids.has_key? ele_id
-                raise InvalidXhtmlError, "id `#{ele_id}' already used (id's must be unique)."
-              end
-            end
-            if AttrsBoolean.include? atname
-              if v
-                attrs[k] = atname.to_s
-              else
-                attrs.delete k
-              end
-            end
-          end
-        end
+        attributes = @tagset.validate_and_transform_attributes!(tag, *args)
+        tag = @tagset.validate_and_transform_tag_name! tag
       end
-
+      element_id = attributes[:id].to_s
+      raise InvalidXhtmlError, "id `#{element_id}' already used (id's must be unique)." if @used_ids.has_key?(element_id)
       if block
         str = capture(&block)
         block = proc { text(str) }
       end
 
       f = fragment { @builder.tag!(tag, *args, &block) }
-      @used_ids[ele_id] = f if ele_id
+      @used_ids[element_id] = f unless element_id.empty?
       f
     end
 
-  private
+    private
 
     # This method is used to intercept calls to helper methods and instance
     # variables.  Here is the order of interception:
@@ -224,37 +175,40 @@ module Markaby
     # * If +sym+ is also the name of an instance variable, the
     #   value of the instance variable is returned.
     # * If +sym+ has come this far and no +tagset+ is found, +sym+ and its arguments are passed to tag!
-    # * If a tagset is found, though, +NoMethodError+ is raised.
+    # * If a tagset is found, the tagset is tole to handle +sym+
     #
     # method_missing used to be the lynchpin in Markaby, but it's no longer used to handle
     # HTML tags.  See html_tag for that.
     def method_missing(sym, *args, &block)
-      if @_helper.respond_to?(sym, true) && !self.class.ignored_helpers.include?(sym)
-        r = @_helper.send(sym, *args, &block)
-        if @output_helpers && r.respond_to?(:to_str)
-          fragment { @builder << r }
-        else
-          r
-        end
-      elsif @assigns.has_key?(sym)
-        @assigns[sym]
-      elsif @assigns.has_key?(stringy_key = sym.to_s)
-        # Rails' ActionView assigns hash has string keys for
-        # instance variables that are defined in the controller.
-        @assigns[stringy_key]
-      elsif instance_variables_for(self).include?(ivar = "@#{sym}".to_sym)
-        instance_variable_get(ivar)
-      elsif @_helper && instance_variables_for(@_helper).include?(ivar)
-        @_helper.instance_variable_get(ivar)
-      elsif instance_methods_for(::Builder::XmlMarkup).include?(sym)
-        @builder.__send__(sym, *args, &block)
-      elsif !@tagset
-        tag!(sym, *args, &block)
-      else
-        super
+      case response_for(sym)
+      when :helper then @_helper.send(sym, *args, &block)
+      when :assigns then @assigns[sym]
+      when :stringy_assigns then @assigns[sym.to_s]
+      when :ivar then instance_variable_get(ivar)
+      when :helper_ivar then @_helper.instance_variable_get(ivar)
+      when :xml_markup then @builder.__send__(sym, *args, &block)
+      when :tag then tag!(sym, *args, &block)
+      when :tagset then @tagset.handle_tag sym, self, *args, &block
+      else super
       end
     end
 
+    def response_for sym
+      return :helper if @_helper.respond_to?(sym, true)
+      return :assigns if @assigns.has_key?(sym)
+      return :stringy_assigns if @assigns.has_key?(sym.to_s)
+      return :ivar if instance_variables_for(self).include?(ivar = "@#{sym}".to_sym)
+      return :helper_ivar if @_helper && instance_variables_for(@_helper).include?(ivar)
+      return :xml_markup if instance_methods_for(::Builder::XmlMarkup).include?(sym)
+      return :tag if @tagset.nil?
+      return :tagset if @tagset.can_handle? sym
+      nil
+    end
+
+    def respond_to_missing? sym, include_private = false
+      !response_for(sym).nil?
+    end
+
     if RUBY_VERSION_ID >= 191
       def instance_variables_for(obj)
         obj.instance_variables
@@ -301,11 +255,15 @@ module Markaby
       undef_method method if method_defined?(method)
     end
 
-  private
+    private
 
-    def method_missing(*args, &block)
+    def method_missing(...)
       transform_stream unless transformed_stream?
-      @str.__send__(*args, &block)
+      @str.__send__(...)
+    end
+
+    def respond_to_missing? sym, *args
+      @str.respond_to? sym
     end
 
     def transform_stream

data/lib/markaby/builder_tags.rb

@@ -1,7 +1,9 @@
+require "markaby/html5"
+
 module Markaby
   module BuilderTags
     (HTML5.tags - [:head]).each do |k|
-      class_eval <<-CODE, __FILE__, __LINE__
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{k}(*args, &block)
           html_tag(#{k.inspect}, *args, &block)
         end
@@ -28,8 +30,8 @@ module Markaby
     # set to <tt>text/html; charset=utf-8</tt>.
     def head(*args, &block)
       tag!(:head, *args) do
-        tag!(:meta, "http-equiv" => "Content-Type", "content" => "text/html; charset=utf-8") if @output_meta_tag == 'xhtml'
-        tag!(:meta, "charset" => "utf-8") if @output_meta_tag == 'html5'
+        tag!(:meta, "http-equiv" => "Content-Type", "content" => "text/html; charset=utf-8") if @output_meta_tag == "xhtml"
+        tag!(:meta, "charset" => "utf-8") if @output_meta_tag == "html5"
         instance_eval(&block)
       end
     end
@@ -56,19 +58,15 @@ module Markaby
 
     # Builds an html tag with HTML5 doctype instead.
     def html5(attrs = {}, &block)
-      enable_html5!
+      self.tagset = Markaby::HTML5
       html5_html(attrs, &block)
     end
 
     def enable_html5!
-      self.tagset = Markaby::HTML5
-
-      Markaby::Builder::HTML5_OPTIONS.each do |k, v|
-        self.instance_variable_set("@#{k}".to_sym, v)
-      end
+      raise NotImplementedError, "Deprecated! Call self.tagset = Markaby::HTML5"
     end
 
-  private
+    private
 
     def xhtml_html(attrs = {}, &block)
       instruct! if @output_xml_instruction

data/lib/markaby/cssproxy.rb

@@ -6,9 +6,9 @@ module Markaby
   class CssProxy
     def initialize(builder, stream, sym)
       @builder = builder
-      @stream  = stream
-      @sym     = sym
-      @attrs   = {}
+      @stream = stream
+      @sym = sym
+      @attrs = {}
 
       @original_stream_length = @stream.length
 
@@ -16,10 +16,10 @@ module Markaby
     end
 
     def respond_to?(sym, include_private = false)
-      include_private || !private_methods.map { |m| m.to_sym }.include?(sym.to_sym) ? true : false
+      (include_private || !private_methods.map { |m| m.to_sym }.include?(sym.to_sym)) ? true : false
     end
 
-  private
+    private
 
     # Adds attributes to an element.  Bang methods set the :id attribute.
     # Other methods add to the :class attribute.

data/lib/markaby/html5.rb

@@ -0,0 +1,118 @@
+require "markaby/xhtml_transitional"
+module Markaby
+  class HTML5 < Tagset
+    class << self
+      def default_options
+        super.merge({
+          output_xml_instruction: false,
+          output_meta_tag: "html5",
+          root_attributes: {}
+        })
+      end
+
+      def custom_element? tag_name
+        tag_name.to_s.include? "_"
+      end
+
+      def can_handle? tag_name
+        custom_element? tag_name
+      end
+
+      def handle_tag tag_name, builder, *args, &block
+        builder.tag! tag_name, *args, &block
+      end
+
+      def validate_and_transform_tag_name! tag_name
+        custom_element?(tag_name) ? custom_element_tag_for(tag_name) : super
+      end
+
+      def custom_element_tag_for tag_name
+        tag_name.to_s.tr("_", "-").to_sym
+      end
+
+      def validate_attribute! tag_name, attribute_name
+        custom_element?(tag_name) || super
+      end
+    end
+
+    @doctype = ["html"]
+    @tagset = XHTMLTransitional.tagset.merge({
+      abbr: Attrs,
+      article: Attrs,
+      aside: Attrs,
+      audio: Attrs,
+      bdi: Attrs,
+      canvas: Attrs,
+      command: Attrs,
+      datalist: Attrs,
+      details: Attrs,
+      embed: Attrs,
+      figure: Attrs,
+      figcaption: Attrs,
+      footer: Attrs,
+      header: Attrs,
+      hgroup: Attrs,
+      keygen: Attrs,
+      mark: Attrs,
+      menu: Attrs,
+      meter: Attrs,
+      nav: Attrs,
+      output: Attrs,
+      progress: Attrs,
+      rp: Attrs,
+      rt: Attrs,
+      ruby: Attrs,
+      section: Attrs,
+      source: Attrs,
+      time: Attrs,
+      track: Attrs,
+      video: Attrs,
+      wbr: Attrs
+    })
+
+    # Additional attributes found in HTML5
+    additional_tags = {
+      a: [:media, :download, :ping],
+      area: [:media, :download, :ping, :hreflang, :rel, :type],
+      base: [:target],
+      button: [:autofocus, :form, :formaction, :formenctype, :formmethod,
+        :formnovalidate, :formtarget],
+      fieldset: [:form, :disabled, :name],
+      form: [:novalidate],
+      label: [:form],
+      html: [:manifest],
+      iframe: [:sandbox, :seamless, :srcdoc],
+      img: [:crossorigin],
+      input: [:autofocus, :placeholder, :form, :required, :autocomplete,
+        :min, :max, :multiple, :pattern, :step, :list, :width, :height,
+        :dirname, :formaction, :formenctype, :formmethod,
+        :formnovalidate, :formtarget],
+      link: [:sizes],
+      meta: [:charset],
+      menu: [:type, :label],
+      object: [:form, :typemustmatch],
+      ol: [:reversed],
+      output: [:form],
+      script: [:async],
+      select: [:autofocus, :form, :required],
+      style: [:scoped],
+      textarea: [:autofocus, :placeholder, :form, :required, :dirname,
+        :maxlength, :wrap]
+    }
+
+    AttrsHTML5 = [:contenteditable, :contextmentu, :draggable, :dropzone,
+      :hidden, :role, :spellcheck, :translate]
+
+    additional_tags.each do |k, v|
+      @tagset[k] += v
+    end
+
+    @tagset.each do |k, v|
+      @tagset[k] += AttrsHTML5
+    end
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+end

data/lib/markaby/kernel_method.rb

@@ -1,8 +1,9 @@
 # You'll need to <tt>require 'markaby/kernel_method'</tt> for this.
+require "markaby"
+
 module Kernel
   # Shortcut for creating a quick block of Markaby.
-  def mab(*args, &block)
-    Markaby::Builder.new(*args, &block).to_s
+  def mab(...)
+    Markaby::Builder.new(...).to_s
   end
 end
-

data/lib/markaby/rails.rb

@@ -0,0 +1,36 @@
+require "markaby"
+
+module Markaby
+  module Rails
+    class TemplateHandler
+      class << self
+        def register!(options = {})
+          self.options = options
+          ActionView::Template.register_template_handler(:mab, new)
+        end
+
+        # TODO: Do we need this?
+        # Default format used by Markaby
+        # class_attribute :default_format
+        # self.default_format = :html
+
+        def options
+          @options ||= {}
+        end
+
+        def options=(val)
+          options.merge!(val)
+          options
+        end
+      end
+
+      def call(template, source = template.source)
+        <<-CODE
+          Markaby::Builder.new(Markaby::Rails::TemplateHandler.options, self) do
+            #{source}
+          end.to_s
+        CODE
+      end
+    end
+  end
+end

data/lib/markaby/tagset.rb

@@ -0,0 +1,89 @@
+module Markaby
+  FORM_TAGS = [:form, :input, :select, :textarea]
+  SELF_CLOSING_TAGS = [:area, :base, :br, :col, :command, :embed, :frame, :hr,
+    :img, :input, :keygen, :link, :meta, :param, :source,
+    :track, :wbr]
+
+  # Common sets of attributes.
+  AttrCore = [:id, :class, :style, :title]
+  AttrI18n = [:lang, :"xml:lang", :dir]
+  AttrEvents = [:onclick,
+    :ondblclick,
+    :onmousedown,
+    :onmouseup,
+    :onmouseover,
+    :onmousemove,
+    :onmouseout,
+    :onkeypress,
+    :onkeydown,
+    :onkeyup]
+  AttrFocus = [:accesskey, :tabindex, :onfocus, :onblur]
+  AttrHAlign = [:align, :char, :charoff]
+  AttrVAlign = [:valign]
+  Attrs = AttrCore + AttrI18n + AttrEvents
+
+  AttrsBoolean = [
+    :checked, :disabled, :multiple, :readonly, :selected, # standard forms
+    :autofocus, :required, :novalidate, :formnovalidate, # HTML5 forms
+    :defer, :ismap, # <script defer>, <img ismap>
+    :compact, :declare, :noresize, :noshade, :nowrap # deprecated or unused
+  ]
+  class Tagset
+    class << self
+      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
+
+      def default_options
+        {tagset: self}
+      end
+
+      def can_handle? tag_name
+        false
+      end
+
+      def handle_tag tag_name, builder, *args, &block
+        raise NoMethodError.new
+      end
+
+      def validate_and_transform_tag_name! tag_name
+        raise(InvalidXhtmlError, "no element `#{tag_name}' for #{doctype}") unless @tagset.has_key?(tag_name)
+        tag_name
+      end
+
+      def validate_and_transform_attributes! tag_name, *args
+        args.last.respond_to?(:to_hash) ? transform_attributes(tag_name, args.last.to_hash) : {}
+      end
+
+      def transform_attributes tag_name, attributes
+        attributes[:name] ||= attributes[:id] if forms.include?(tag_name) && attributes[:id]
+        attributes.transform_keys! { |name| transform_attribute_name name }
+        hashed_attributes = attributes.keys.select { |name| attributes[name].is_a? Hash }
+        hashed_attributes.each { |name| transform_attribute_hash attributes, name }
+        attributes.reject! { |name, value| name.nil? || (AttrsBoolean.include?(name) && value.nil?) }
+        attributes.keys.each { |name| validate_attribute! tag_name, name }
+        attributes
+      end
+
+      def transform_attribute_name name
+        name.to_s.downcase.tr("_", "-").to_sym
+      end
+
+      def transform_attribute_hash attributes, prefix
+        values = attributes[prefix]
+        expanded_attributes = {}
+        values.each do |suffix, value|
+          name = transform_attribute_name "#{prefix}-#{suffix}"
+          expanded_attributes[name] = value
+        end
+        attributes.merge!(expanded_attributes).delete(prefix)
+      end
+
+      def validate_attribute! tag_name, attribute_name
+        raise InvalidXhtmlError, "no attribute `#{attribute_name}' on #{tag_name} elements" unless valid_attribute_name? tag_name, attribute_name
+      end
+
+      def valid_attribute_name? tag_name, attribute_name
+        attribute_name.to_s.start_with?(":", "data-", "aria-") || @tagset[tag_name].include?(attribute_name)
+      end
+    end
+  end
+end

data/lib/markaby/version.rb

@@ -1,3 +1,7 @@
 module Markaby
-  VERSION = '0.8.1'
+  MAJOR = 0
+  MINOR = 9
+  TINY = 1
+
+  VERSION = "#{MAJOR}.#{MINOR}.#{TINY}"
 end

data/lib/markaby/xhtml_frameset.rb

@@ -0,0 +1,13 @@
+module Markaby
+  class XHTMLFrameset < XmlTagset
+    @doctype = ["-//W3C//DTD XHTML 1.0 Frameset//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd"]
+    @tagset = XHTMLTransitional.tagset.merge({
+      frameset: AttrCore + [:rows, :cols, :onload, :onunload],
+      frame: AttrCore + [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :noresize, :scrolling]
+    })
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+end

data/lib/markaby/xhtml_strict.rb

@@ -0,0 +1,89 @@
+module Markaby
+  # All the tags and attributes from XHTML 1.0 Strict
+  class XHTMLStrict < XmlTagset
+    @doctype = ["-//W3C//DTD XHTML 1.0 Strict//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"]
+    @tagset = {
+      html: AttrI18n + [:id, :xmlns],
+      head: AttrI18n + [:id, :profile],
+      title: AttrI18n + [:id],
+      base: [:href, :id],
+      meta: AttrI18n + [:id, :http, :name, :content, :scheme, :"http-equiv"],
+      link: Attrs + [:charset, :href, :hreflang, :type, :rel, :rev, :media],
+      style: AttrI18n + [:id, :type, :media, :title, :"xml:space"],
+      script: [:id, :charset, :type, :src, :defer, :"xml:space"],
+      noscript: Attrs,
+      body: Attrs + [:onload, :onunload],
+      div: Attrs,
+      p: Attrs,
+      ul: Attrs,
+      ol: Attrs,
+      li: Attrs,
+      dl: Attrs,
+      dt: Attrs,
+      dd: Attrs,
+      address: Attrs,
+      hr: Attrs,
+      pre: Attrs + [:"xml:space"],
+      blockquote: Attrs + [:cite],
+      ins: Attrs + [:cite, :datetime],
+      del: Attrs + [:cite, :datetime],
+      a: Attrs + AttrFocus + [:charset, :type, :name, :href, :hreflang, :rel, :rev, :shape, :coords],
+      span: Attrs,
+      bdo: AttrCore + AttrEvents + [:lang, :"xml:lang", :dir],
+      br: AttrCore,
+      em: Attrs,
+      strong: Attrs,
+      dfn: Attrs,
+      code: Attrs,
+      samp: Attrs,
+      kbd: Attrs,
+      var: Attrs,
+      cite: Attrs,
+      abbr: Attrs,
+      acronym: Attrs,
+      q: Attrs + [:cite],
+      sub: Attrs,
+      sup: Attrs,
+      tt: Attrs,
+      i: Attrs,
+      b: Attrs,
+      big: Attrs,
+      small: Attrs,
+      object: Attrs + [:declare, :classid, :codebase, :data, :type, :codetype, :archive, :standby, :height, :width, :usemap, :name, :tabindex],
+      param: [:id, :name, :value, :valuetype, :type],
+      img: Attrs + [:src, :alt, :longdesc, :height, :width, :usemap, :ismap],
+      map: AttrI18n + AttrEvents + [:id, :class, :style, :title, :name],
+      area: Attrs + AttrFocus + [:shape, :coords, :href, :nohref, :alt],
+      form: Attrs + [:action, :method, :enctype, :onsubmit, :onreset, :accept, :accept],
+      label: Attrs + [:for, :accesskey, :onfocus, :onblur],
+      input: Attrs + AttrFocus + [:type, :name, :value, :checked, :disabled, :readonly, :size, :maxlength, :src, :alt, :usemap, :onselect, :onchange, :accept],
+      select: Attrs + [:name, :size, :multiple, :disabled, :tabindex, :onfocus, :onblur, :onchange],
+      optgroup: Attrs + [:disabled, :label],
+      option: Attrs + [:selected, :disabled, :label, :value],
+      textarea: Attrs + AttrFocus + [:name, :rows, :cols, :disabled, :readonly, :onselect, :onchange],
+      fieldset: Attrs,
+      legend: Attrs + [:accesskey],
+      button: Attrs + AttrFocus + [:name, :value, :type, :disabled],
+      table: Attrs + [:summary, :width, :border, :frame, :rules, :cellspacing, :cellpadding],
+      caption: Attrs,
+      colgroup: Attrs + AttrHAlign + AttrVAlign + [:span, :width],
+      col: Attrs + AttrHAlign + AttrVAlign + [:span, :width],
+      thead: Attrs + AttrHAlign + AttrVAlign,
+      tfoot: Attrs + AttrHAlign + AttrVAlign,
+      tbody: Attrs + AttrHAlign + AttrVAlign,
+      tr: Attrs + AttrHAlign + AttrVAlign,
+      th: Attrs + AttrHAlign + AttrVAlign + [:abbr, :axis, :headers, :scope, :rowspan, :colspan],
+      td: Attrs + AttrHAlign + AttrVAlign + [:abbr, :axis, :headers, :scope, :rowspan, :colspan],
+      h1: Attrs,
+      h2: Attrs,
+      h3: Attrs,
+      h4: Attrs,
+      h5: Attrs,
+      h6: Attrs
+    }
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+end