markaby 0.9.0 → 0.9.1

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
@@ -64,7 +66,7 @@ module Markaby
       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,9 +1,9 @@
 # You'll need to <tt>require 'markaby/kernel_method'</tt> for this.
-require 'markaby'
+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

@@ -1,10 +1,10 @@
-require 'markaby'
+require "markaby"
 
 module Markaby
   module Rails
     class TemplateHandler
       class << self
-        def register!(options={})
+        def register!(options = {})
           self.options = options
           ActionView::Template.register_template_handler(:mab, new)
         end
@@ -19,15 +19,15 @@ module Markaby
         end
 
         def options=(val)
-          self.options.merge!(val)
-          self.options
+          options.merge!(val)
+          options
         end
       end
 
-      def call(template)
+      def call(template, source = template.source)
         <<-CODE
           Markaby::Builder.new(Markaby::Rails::TemplateHandler.options, self) do
-            #{template.source}
+            #{source}
           end.to_s
         CODE
       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

@@ -0,0 +1,7 @@
+module Markaby
+  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

data/lib/markaby/xhtml_transitional.rb

@@ -0,0 +1,61 @@
+require "markaby/xml_tagset"
+require "markaby/xhtml_strict"
+module Markaby
+  # Additional tags found in XHTML 1.0 Transitional
+  class XHTMLTransitional < XmlTagset
+    @doctype = ["-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"]
+    @tagset = XHTMLStrict.tagset.merge({
+      strike: Attrs,
+      center: Attrs,
+      dir: Attrs + [:compact],
+      noframes: Attrs,
+      basefont: [:id, :size, :color, :face],
+      u: Attrs,
+      menu: Attrs + [:compact],
+      iframe: AttrCore + [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :scrolling, :align, :height, :width],
+      font: AttrCore + AttrI18n + [:size, :color, :face],
+      s: Attrs,
+      applet: AttrCore + [:codebase, :archive, :code, :object, :alt, :name, :width, :height, :align, :hspace, :vspace],
+      isindex: AttrCore + AttrI18n + [:prompt]
+    })
+
+    # Additional attributes found in XHTML 1.0 Transitional
+    additional_tags = {
+      script: [:language],
+      a: [:target],
+      td: [:bgcolor, :nowrap, :width, :height],
+      p: [:align],
+      h5: [:align],
+      h3: [:align],
+      li: [:type, :value],
+      div: [:align],
+      pre: [:width],
+      body: [:background, :bgcolor, :text, :link, :vlink, :alink],
+      ol: [:type, :compact, :start],
+      h4: [:align],
+      h2: [:align],
+      object: [:align, :border, :hspace, :vspace],
+      img: [:name, :align, :border, :hspace, :vspace],
+      link: [:target],
+      legend: [:align],
+      dl: [:compact],
+      input: [:align],
+      h6: [:align],
+      hr: [:align, :noshade, :size, :width],
+      base: [:target],
+      ul: [:type, :compact],
+      br: [:clear],
+      form: [:name, :target],
+      area: [:target],
+      h1: [:align]
+    }
+
+    additional_tags.each do |k, v|
+      @tagset[k] += v
+    end
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+end

data/lib/markaby/xml_tagset.rb

@@ -0,0 +1,19 @@
+require "markaby/tagset"
+module Markaby
+  # Additional tags found in XHTML 1.0 Frameset
+  class XmlTagset < Tagset
+    class << self
+      def default_options
+        super.merge({
+          output_xml_instruction: true,
+          output_meta_tag: "xhtml",
+          root_attributes: {
+            xmlns: "http://www.w3.org/1999/xhtml",
+            "xml:lang": "en",
+            lang: "en"
+          }
+        })
+      end
+    end
+  end
+end

data/lib/markaby.rb

@@ -4,7 +4,7 @@
 # as well as the full set of Markaby classes.
 #
 # For a full list of features and instructions, see the README.
-$:.unshift File.expand_path(File.dirname(__FILE__))
+$:.unshift __dir__
 
 # Markaby is a module containing all of the great Markaby classes that
 # do such an excellent job.
@@ -17,15 +17,11 @@ $:.unshift File.expand_path(File.dirname(__FILE__))
 # * Markaby::Tags: lists the roles of various XHTML tags to help Builder
 #   use these tags as they are intended.
 module Markaby
-  MAJOR = 0
-  MINOR = 9
-  TINY = 0
-
-  VERSION = "#{MAJOR}.#{MINOR}.#{TINY}"
-
   class InvalidXhtmlError < StandardError; end
 end
 
-require 'builder' unless defined?(Builder)
-require 'markaby/builder'
-require 'markaby/cssproxy'
+require "markaby/version"
+require "builder" unless defined?(Builder)
+require "markaby/tagset"
+require "markaby/builder"
+require "markaby/cssproxy"

data/spec/markaby/builder_spec.rb

@@ -39,7 +39,7 @@ module Markaby
           end
         end.new
 
-        builder = Markaby::Builder.new({:helpers => nil}, helper)
+        builder = Markaby::Builder.new({helpers: nil}, helper)
         builder.some_method.should == "a value"
       end
     end

data/spec/markaby/css_proxy_spec.rb

@@ -9,34 +9,35 @@ describe Markaby::CssProxy do
   end
 
   def mock_builder
-    mock_builder = Class.new do
-      def tag!(*args); end
+    Class.new do
+      def tag!(*args)
+      end
     end.new
   end
 
   it "responds_to_everything" do
-    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-    proxy.respond_to?(:any_method).should be_true
-    proxy.respond_to?(:foobarbazasdfasdfadfs).should be_true
+    proxy = Markaby::CssProxy.new(mock_builder, "stream", :sym)
+    proxy.respond_to?(:any_method).should be true
+    proxy.respond_to?(:foobarbazasdfasdfadfs).should be true
   end
 
   it "does_not_respond_to_method_missing" do
-    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
+    proxy = Markaby::CssProxy.new(mock_builder, "stream", :sym)
     proxy.should_not respond_to(:method_missing)
   end
 
   it "does_respond_to_private_instance_methods_with_private_flag_set_to_true" do
-    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-    proxy.respond_to?(:method_missing, true).should be_true
+    proxy = Markaby::CssProxy.new(mock_builder, "stream", :sym)
+    proxy.respond_to?(:method_missing, true).should be true
   end
 
   it "does_not_respond_to_private_instance_methods_with_private_flag_set_to_false" do
-    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-    proxy.respond_to?(:method_missing, false).should be_false
+    proxy = Markaby::CssProxy.new(mock_builder, "stream", :sym)
+    proxy.respond_to?(:method_missing, false).should be false
   end
 
   it "respond_to_should_always_return_boolean" do
-    proxy = Markaby::CssProxy.new(mock_builder, 'stream', :sym)
-    proxy.respond_to?(:method_missing, :a_value).should be_true
+    proxy = Markaby::CssProxy.new(mock_builder, "stream", :sym)
+    proxy.respond_to?(:method_missing, :a_value).should be true
   end
 end