dom 0.5.1 → 1.0.0

data/lib/dom.rb

@@ -1,8 +1,55 @@
 # frozen_string_literal: true
+
+# Copyright (c) 2016 sawa
+
 require "stringio"
 require "strscan"
 require "htmlentities"
 
+class DomString < String; end
+
+using (Module.new do
+	refine String do
+		AnsiColor = {
+			"1" => "bold",
+			"4" => "underline",
+			"30" => "black",
+			"31" => "red",
+			"32" => "green",
+			"33" => "yellow",
+			"34" => "blue",
+			"35" => "magenta",
+			"36" => "cyan",
+			"37" => "white",
+			"40" => "bg-black",
+			"41" => "bg-red",
+			"42" => "bg-green",
+			"43" => "bg-yellow",
+			"44" => "bg-blue",
+			"45" => "bg-magenta",
+			"46" => "bg-cyan",
+			"47" => "bg-white",
+		}
+		def dom_escape tag = nil
+			case tag; when :style, :script then self else Dom::Coder.encode(self) end
+		end
+		def _ansi2html
+			sc = StringScanner.new(self)
+			io = StringIO.new
+			io.print(
+				if sc.scan(/\e\[0?m/o) then '</span>'
+				elsif sc.scan(/\e\[0?(\d+)m/o) then '<span class="%s">' % AnsiColor[sc[1]]
+				end ||
+			sc.scan(/./mo)) until sc.eos?
+			io.string
+		end
+	end
+
+	refine DomString do
+		def dom_escape tag = nil; self end
+	end
+end)
+
 class File
 	def self.relativize f; f.sub(%r{\A/}o, "") end
 end
@@ -10,6 +57,7 @@ end
 module Dom
 	Coder = HTMLEntities.new
 	Indent = "  "
+	private_constant :Indent
 	def self.compact; singleton_class.class_eval{alias join join_compact} end
 	def self.nested; singleton_class.class_eval{alias join join_nested} end
 	def self.pre; singleton_class.class_eval{alias join join_pre} end
@@ -66,60 +114,29 @@ end
 class NilClass
 	public :dom
 	public :jsonml
+	def mounted; nil end
 end
 
 class String
-	def dom tag, mounted: nil, **attr
-		"<%s>%s</%s>".%(
-			Dom.format(tag, attr)
-			.insert(1, (block_given? ? yield(self) : self).dom_escape(tag)._ansi2html)
-		)
+	def dom tag = nil, mounted: nil, **attr
+		if tag
+			"<%s>%s</%s>".%(
+				Dom.format(tag, attr)
+				.insert(1, (block_given? ? yield(self) : self).dom_escape(tag)._ansi2html)
+			)
+		else
+			dom_escape
+		end
 		.dom_escaped.mounted_set(mounted)
 	end
-	def jsonml tag, attr = nil
-		[*Dom.json_format(tag, attr), self]
-	end
+	def jsonml tag, attr = nil; [*Dom.json_format(tag, attr), self] end
 	def mounted; nil end
-	def dom_escape tag = nil
-		case tag; when :style, :script then self else Dom::Coder.encode(self) end
-	end
 	def dom_escaped; DomString.new(self) end
-	AnsiColor = {
-		"1" => "bold",
-		"4" => "underline",
-		"30" => "black",
-		"31" => "red",
-		"32" => "green",
-		"33" => "yellow",
-		"34" => "blue",
-		"35" => "magenta",
-		"36" => "cyan",
-		"37" => "white",
-		"40" => "bg-black",
-		"41" => "bg-red",
-		"42" => "bg-green",
-		"43" => "bg-yellow",
-		"44" => "bg-blue",
-		"45" => "bg-magenta",
-		"46" => "bg-cyan",
-		"47" => "bg-white",
-	}
-	def _ansi2html
-		sc = StringScanner.new(self)
-		io = StringIO.new
-		io.print(
-			if sc.scan(/\e\[0?m/o) then '</span>'
-			elsif sc.scan(/\e\[0?(\d+)m/o) then '<span class="%s">' % AnsiColor[sc[1]]
-			end ||
-		sc.scan(/./mo)) until sc.eos?
-		io.string
-	end
 	def ansi2html; _ansi2html.dom_escaped end
 end
 
 class DomString < String
 	def to_s; self end
-	def dom_escape tag = nil; self end
 	def dom_escaped; self end
 	def mounted_set *mounted
 		mounted.compact!
@@ -138,14 +155,17 @@ class Array
 		a = self
 		a = block_given? ? map(&Proc.new) : flatten if recurse.empty?
 		if recurse.length <= 1
-			if e = a.find{|e| e.kind_of?(String).! and e.kind_of?(Array).!}
+			#!index: Using `index` instead of `find` to be able to detect `nil`. 
+			#   (Which turned out irrelevant.)
+			if i = a.index{|e| e.kind_of?(String).! and e.kind_of?(Array).! and e.nil?.!}
 				raise ArgumentError
-				.new("Expecting all array elements to be a string: `#{e.class}:#{e.inspect}'")
+				.new("Expecting all array elements to be a string: `#{a[i].class}:#{a[i].inspect}'")
 			end
 		else
-			if e = a.find{|e| e.kind_of?(Array).!}
+			#!index:
+			if i = a.index{|e| e.kind_of?(Array).!}
 				raise ArgumentError
-				.new("Cannot apply tag `#{recurse[-2].inspect}' to `#{e.class}:#{e.inspect}'")
+				.new("Cannot apply tag `#{recurse[-2].inspect}' to `#{a[i].class}:#{a[i].inspect}'")
 			end
 		end
 		a = a.map{|e| e.dom(*recurse, &(Proc.new if block_given?))} unless recurse.empty?
@@ -153,9 +173,7 @@ class Array
 		s = "<%s>%s</%s>" % Dom.format(tag, attr).insert(1, s) unless tag.nil?
 		s.dom_escaped.mounted_set(*a.map(&:mounted), mounted)
 	end
-	def jsonml tag, attr = nil
-		[*Dom.json_format(attr), *self]
-	end
+	def jsonml tag, attr = nil; [*Dom.json_format(attr), *self] end
 end
 
 Dom.compact

data/license

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2013--2016 sawa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec

@@ -0,0 +1,387 @@
+#! frozen_string_literal: false
+#!ruby
+
+gemspec "dom.gemspec"
+manage "lib/dom.rb"
+
+spec "=License",
+	"The MIT License (MIT)",
+	"Copyright (c) 2013-2016 sawa",
+	"Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:",
+	"The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.",
+	"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.",
+coda
+
+spec "=Overview",
+	"The `\"dom\"` gem is a library to generate HTML/XML code from Ruby commands. It replaces conventional approcaches using template engines, or certain kind of libraries with a similar purpose.",
+	"With conventional template engines, you need to write HTML/XML code in a dedicated language in an external file or here document, which is then parsed. With the `\"dom\"` gem, you can describe HTML/XML structures in Ruby language seemlessly with other parts of Ruby code.",
+	"Some conventional libraries define command names that represent the type of DOM node, which may expect an input like this:",
+	<<~'RUBY'.code,
+		h1{"Hello World!"} #=> "<h1>Hello World!</h1>"
+		div{"Hello World!"} #=> "<div>Hello World!</div>"
+	RUBY
+	"Such notation lacks flexibility. For every type of node, the corresponding command needs to be defined in advance. A user, would also not be able to use an original node type that is not predefined in the library.",
+"Unlike such systems, `\"dom\"` gem makes use of a fixed method name `dom`, which takes a symbol argument representing the node type. The equivalent of the input above in `\"dom\"` is:",
+	<<~'RUBY'.code,
+		"Hello World!".dom(:h1) #=> "<h1>Hello World!</h1>"
+		"Hello World!".dom(:div) #=> "<div>Hello World!</div>"
+	RUBY
+	"Some conventional libraries take the content of a node as a block. Nested nodes would then require nested blocks:",
+	<<~'RUBY'.code,
+		div{p{span{"Hello World!"}}}
+		#=> "<div><p><span>Hello World!</span></p></div>"
+	RUBY
+	"As the structure becomes complicated, it becomes more difficult to keep the block opening paired with a closing.",
+	"In `\"dom\"`, the content of a node is the receiver of a method. Node embedding is described as method chaining, which avoids unnecessary nesting, and confirms to the Rubyistic coding style.",
+	<<~'RUBY'.code,
+		"Hello World!".dom(:span).dom(:p).dom(:div)
+		#=> "<div><p><span>Hello World!</span></p></div>"
+	RUBY
+coda
+
+spec "=Usage",
+	"Require dom (usually at the beginning of a file) before using its methods:",
+	<<~'RUBY'.code,
+		require "dom"
+	RUBY
+	"To surround a string with a tag, use the `dom` method. Pass the tag name as a symbol, with an optional hash, whose keys are symbols, and values that are either `nil`, `true`, `false`, or other kinds of objects that have the `to_s` methods inmplemented.",
+		<<~'RUBY'.code,
+			"foo".dom(:span, class: "bar") # => "<span class=\"bar\">foo</span>"
+			"foo".dom(:span, data_1: nil, data_2: 3) # => "<span data-2=\"3\">foo</span>"
+		RUBY
+		"The `dom` method can be chained to generate nested structures.",
+		<<~'RUBY'.code,
+			"Hello World!".dom(:span).dom(:p).dom(:div)
+			#=> "<div><p><span>Hello World!</span></p></div>"
+		RUBY
+		"When `dom` applies to an array, its elements are joined.",
+		<<~'RUBY'.code,
+				["foo", "bar"].dom(:div, class: "bar")
+				# => "<div class=\"bar\">foobar</div>"
+		RUBY
+		"When multiple tags are passed to a single `dom` method call, the tags are distributed and are percolated into the nested arrays.",
+		<<~'RUBY'.code,
+			[["foo1", "foo2"], ["bar1", "bar2"]].dom(:td, :tr, :table)
+			# => "<table><tr><td>foo1</td><td>foo2</td></tr><tr><td>bar1</td><td>bar2</td></tr></table>"
+		RUBY
+coda
+
+module Dom
+	hide spec "::Coder",
+	coda
+
+	hide spec "::Indent",
+		"! Indentation internally used in `join` whem the mode is `nested` or `pre`.",
+		UT =~ /\s+/,
+	coda
+
+	spec ".compact",
+		{"()" => Class},
+		"Sets the output to compact mode. Usually the best for production use. It is compressed, and is not convenient for human reading.",
+		UT.succeed?,
+		"Dom.compact".setup,
+		<<~'RUBY'.code,
+			Dom.compact
+		RUBY
+	coda
+
+	spec ".nested",
+		{"()" => Class},
+		"Sets the output to nested mode. Usually the best for development use. It may not be optimized for production use.",
+		UT.succeed?,
+		"Dom.compact".setup,
+		<<~'RUBY'.code,
+			Dom.nested
+		RUBY
+	coda
+
+	spec ".pre",
+		{"()" => Class},
+		"Sets the output to a mode that preserves the line numbers of the original by inserting HTML's comment expressions. This is for special usage. Normally, you will not need to to set to this mode.",
+		UT.succeed?,
+		"Dom.compact".setup,
+		<<~'RUBY'.code,
+			Dom.pre
+		RUBY
+	coda
+
+	hide spec ".join_compact",
+		"! Internally used `join` method for `compact` mode.",
+	coda
+
+	hide spec ".join_nested",
+		"! Internally used `join` method for `nested` mode.",
+	coda
+
+	hide spec ".join_pre",
+		"! Internally used `join` method for `pre` mode.",
+	coda
+
+	hide spec ".format",
+		"! Converts a hash into an HTML attribute. An attribute `:foo` with value `true` and `false` will be converted to the string `foo=\"\"` and `foo=\"none\"`, respectively. Key-value pairs with the value `nil` will be excluded from the output. Other values will be applied `to_s`. The pairs will be joined by a space, and the whole string will be prepended by a space.",
+		UT(:script, foo: "abcabc") == ["script foo=\"abcabc\"", "script"],
+		UT(:div, foo: nil) == ["div", "div"],
+		UT(:div, foo: false) == ["div foo=\"none\"", "div"],
+		UT(:script, foo: true) == ["script foo=\"\"", "script"],
+		UT(:div, foo: 3) == ["div foo=\"3\"", "div"],
+		UT(:div, foo1: "abcabc", foo2: nil, foo3: false, foo4: true, foo5: 3) ==
+		["div foo1=\"abcabc\" foo3=\"none\" foo4=\"\" foo5=\"3\"", "div"],
+	coda
+
+	hide spec ".json_format",
+		"! Creates an array to be used in JSON.",
+		UT(:div, style: "foo") == ["div", {"style" => "foo"}],
+	coda
+
+	hide spec ".hyphenize",
+		"!Converts underscore into hyphen. Used in `json_format`.",
+		UT("FooBar_Baz-Foo") == "FooBar-Baz-Foo",
+	coda
+
+	hide spec ".join",
+		"! Joins strings in an array. Depending on the mode, either aliased to `join_compact`, `join_nested`, or `join_pre`.",
+	coda
+end
+
+class String
+	spec "#dom",
+		{"(tag, mounted: nil, **attr)" => DomString},
+		"When `dom` is called on a string, it will create a tag including that string as the content.",
+		<<~'RUBY'.code,
+			"foo".dom(:span, class: "bar") # => "<span class=\"bar\">foo</span>"
+		RUBY
+		"foo".UT(:span, class: "bar") == "<span class=\"bar\">foo</span>",
+		"Attributes are passed as a hash. A key `:foo` with value `true` or `false` will be converted to the string `foo=\"\"` or `foo=\"none\"`, respectively. Key-value pairs with the value `nil` will be excluded from the output. For other values, `to_s` will be applied. The pairs will be joined by a space, and the whole string will be prepended by a space.",
+		<<~'RUBY'.code,
+			"foo".dom(:span, data_1: nil, data_2: 3) # => "<span data-2=\"3\">foo</span>"
+		RUBY
+		"foo".UT(:span, data_1: nil, data_2: 3) == "<span data-2=\"3\">foo</span>",
+		"HTML escaping will be automatically applied unless the `tag` is `:script` or `:style`:",
+		<<~'RUBY'.code,
+			"<".dom(:span) # => "<span>&lt;</span>"
+			"if(3 < 5){alert('foo')};".dom(:script) # => "<script>if(3 < 5){alert('foo')};</script>"
+		RUBY
+	coda
+
+	hide spec "#mounted",
+		"! Gets the state of inner elements, namely whether they are mounted once. For `String`, this is `nil`.",
+		"fresh string".UT.nil?,
+	coda
+
+#	hide spec "#dom_escape",
+#		"<".UT == "&lt;",
+#		"&".UT == "&amp;",
+#	coda
+
+	spec "#dom_escaped",
+		{"()" => DomString},
+		"Marks `self` so that it will not be further HTML escaped. Internally, it is converted to an instance of `DomString` class, which is never further escaped.",
+	"When a string is already HTML escaped but has not been done so  via the `dom` method, further applying `dom` to that string will incorrctly doublely apply HTML marking. The string must be marked with this method to avoid HTML escape. For example, without applying `dom_escaped`, an already-escaped string is doublely escaped, giving wrong results:",
+		<<~'RUBY'.code,
+			"3 &lt; 5".dom(:span)
+			# => "<span>3 &amp;lt; 5</span>"
+			["a".dom(:span, class: "bold"), "b"].join.dom
+			#=> "&lt;span class=&quot;bold&quot;&gt;a&lt;/span&gt;b"
+		RUBY
+		"To get the correct results, `dom_escaped` must be applied before application of `dom`:",
+		<<~'RUBY'.code,
+			"3 &lt; 5".dom_escaped.dom(:span)
+			# => "<span>3 &lt; 5</span>"
+			["a".dom(:span, class: "bold"), "b"].join.dom_escaped.dom
+			#=> "<span class=\"bold\">a</span>b"
+		RUBY
+		" 3 &lt; 5".UT.dom(:span) == " 3 &lt; 5".dom_escaped.dom(:span),
+		["a".dom(:span, class: "bold"), "b"].join.UT.dom == "<span class=\"bold\">a</span>b",
+		"When the string is created by `dom` method, such consideration is unnecessary (although it will not harm if `dom_escaped` is redundantly applied).",
+		<<~'RUBY'.code,
+			["a".dom(:span, class: "bold"), "b"].dom.dom
+			# => "<span class=\"bold\">a</span>b"
+		RUBY
+		" 3 &lt; 5".UT.dom(:span) == " 3 &lt; 5".dom_escaped.dom(:span),
+		["a".dom(:span, class: "bold"), "b"].join.UT.dom == "<span class=\"bold\">a</span>b",
+		"foo".UT.instance_of?(DomString),
+		"a = \"foo\"".setup,
+		expr("a").UT == expr("a"),
+		expr("a").UT === expr("a"),
+		expr("a").UT.eql?(expr("a")),
+	coda
+
+	hide spec "#jsonml",
+	coda
+
+	hide spec "::AnsiColor",
+	coda
+
+	hide spec "#ansi2html",
+		"! Internally called by `ansi2html`.",
+	coda
+end
+
+hide spec "::DomString",
+coda
+
+class DomString
+	hide spec "#to_s",
+		"! A `DomString` instance behaves like a `String` except that dom escape does not modify it. This class is to mark that the instance has alrady gone under dom escaping so that further application of dom escaping does not have effect. It makes dom escaping idempotent.",
+		expr("DomString.new").UT.instance_of?(DomString),
+		"a = DomString.new(\"foo\")".setup,
+		expr("a").UT == expr("a"),
+		expr("a").UT === expr("a"),
+		expr("a").UT.eql?(expr("a")),
+	coda
+
+#	hide spec "#dom_escape",
+#	coda
+
+	spec "#dom",
+		"foo".dom_escaped.UT(:span, class: "bar") == "<span class=\"bar\">foo</span>",
+	coda
+
+	spec "#dom_escaped",
+		expr("DomString.new(\"foo\")").UT.instance_of?(DomString),
+	coda
+
+	hide spec "#mounted",
+		"! Gets the mounted state of `self`. This is a flag indicating whether the string-like object has once been mounted in the web browser.",
+	coda
+
+	hide spec "#mounted_set",
+		"! Sets the state of inner elements, namely whether they are mounted once.",
+	coda
+end
+
+module Kernel
+	spec "#dom",
+		{"(tag, mounted: nil, **attr)" => DomString},
+		"When `dom` is used without an explicit receiver, it will create a self-closing tag.",
+		<<~'RUBY'.code,
+			dom(:img, source: "/tmp/foo.png") # => "<img source=\"/tmp/foo.png\" />"
+		RUBY
+		"In the following example, `Kernel#dom` is called at the embedded level. See `Array#dom`.",
+		<<~'RUBY'.code,
+			Array.new(3).dom(:col, :colgroup) # => "<colgroup><col /><col /><col /></colgroup>"
+		RUBY
+		TOPLEVEL_BINDING.receiver.UT(:img, source: "/tmp/foo.png") == "<img source=\"/tmp/foo.png\" />",
+		nil.UT(:foo) == "<foo />",
+	coda
+
+	hide spec "#jsonml",
+		"! Generates a jsonml string.",
+	coda
+end
+
+hide spec "::NilClass",
+coda
+
+class NilClass
+	hide spec "#mounted",
+		"! Gets the state of inner elements, namely whether they are mounted once. For `NilClass`, this is `nil`.",
+		nil.UT.nil?,
+	coda
+end
+
+class Array
+	spec "#dom",
+		{"(tag, mounted: nil, **attr)" => DomString},
+		"Concatenates the elements and puts them inside the tag.",
+		<<~'RUBY'.code,
+				["foo", "bar"].dom(:div, class: "bar") # => "<div class=\"bar\">foobar</div>"
+		RUBY
+		["foo", "bar"].UT(:div, class: "bar")  == "<div class=\"bar\">foobar</div>",
+		{"()" => DomString},
+		"When no argument is given or an explicit `nil` is given, it joins its elements.",
+		<<~'RUBY'.code,
+			["foo", "bar"].dom # => "foobar",
+			["foo", "bar"].dom(nil) # => "foobar",
+		RUBY
+		["foo", "bar"].UT == "foobar",
+		RETURN.is_a?(DomString),
+		["foo", "bar"].UT(nil) == "foobar",
+		RETURN.is_a?(DomString),
+		{"(*tags, mounted: nil, **attr)" => DomString},
+		"When more than one tag is provided, it applies `dom` to each of its elements with the tags  passed except for the last tag (with no other parameters). The last tag and the other parameters are used to apply `dom` to the result.",
+		<<~'RUBY'.code,
+			[["foo1", "foo2"], ["bar1", "bar2"]].dom(:td, :tr, :table)
+			# => "<table><tr><td>foo1</td><td>foo2</td></tr><tr><td>bar1</td><td>bar2</td></tr></table>"
+
+			"Array.new(3)".dom(:col, :colgroup)
+			#=> "<colgroup><col /><col /><col /></colgroup>"
+
+			[["a", 1], ["b", "c"]].dom(:td, :tr)
+			# => ArgumentError
+
+			[[["a", "b"], "c"], "d"].dom(:bar, :foo)
+			# => "<foo><bar>abc</bar><bar>d</bar></foo>"
+
+			["x"].dom(:a, :b, :c, :d)
+			# => ArgumentError
+	RUBY
+		[["foo1", "foo2"], ["bar1", "bar2"]].UT(:td, :tr, :table) ==
+			"<table><tr><td>foo1</td><td>foo2</td></tr><tr><td>bar1</td><td>bar2</td></tr></table>",
+		RETURN.is_a?(DomString),
+		expr("Array.new(3)").UT(:col, :colgroup) == "<colgroup><col /><col /><col /></colgroup>",
+#		note "flatten", "This is necessary so that `mounted` can be applied to all its elements, which is only defined for `String` and `DomString`."
+		[["a", 1], ["b", "c"]].UT(:td, :tr).raise?(ArgumentError),
+		[[["a", "b"], "c"], "d"].UT(:bar, :foo) == "<foo><bar>abc</bar><bar>d</bar></foo>",
+		["x"].UT(:a, :b, :c, :d).raise?(ArgumentError, message: /Cannot apply tag/),
+	"Passing `nil` as the last argument in a sequence:",
+		<<~'RUBY'.code,
+			[["foo1", "foo2"], ["bar1", "bar2"]].dom(:td, :tr, nil)
+			# => "<tr><td>foo1</td><td>foo2</td></tr><tr><td>bar1</td><td>bar2</td></tr>"
+
+			[["a", "b"], ["c", "d"]].dom(:div, nil, nil)
+			# => "<div>a</div><div>b</div><div>c</div><div>d</div>"
+
+			[["a", "b"], ["c", "d"]].dom(:div, nil)
+			# => "<div>ab</div><div>cd</div>"
+		RUBY
+		[["foo1", "foo2"], ["bar1", "bar2"]].UT(:td, :tr, nil) ==
+		"<tr><td>foo1</td><td>foo2</td></tr><tr><td>bar1</td><td>bar2</td></tr>",
+		RETURN.is_a?(DomString),
+		[["a", "b"], ["c", "d"]].UT(:div, nil, nil) == "<div>a</div><div>b</div><div>c</div><div>d</div>",
+		[["a", "b"], ["c", "d"]].UT(:div, nil) == "<div>ab</div><div>cd</div>",
+		"Cf.",
+		<<~'RUBY'.code,
+			[["a", "b"], ["c", "d"]].dom(nil, :div)
+			# => "<div>abcd</div>"
+		RUBY
+		[["a", "b"], ["c", "d"]].UT(nil, :div) == "<div>abcd</div>",
+		{"(*tags, mounted: nil, **attr, &pr)" => DomString},
+		"When a block is passed, the array depth to which the block is applied depends on the class of the receiver that corresponds to the inner most tag.",
+		"When the receiver that corresponds to the inndermost tag is an array, the block is applied to each of its elements.",
+		<<~'RUBY'.code,
+			["a", "b"].dom(:foo){|e| e * 2}
+			# => "<foo>aabb</foo>"
+
+			[["a", "b"], ["c", "d"]].dom(:bar, :foo){|e| e * 2}
+			# => "<foo><bar>aabb</bar><bar>ccdd</bar></foo>"
+		RUBY
+		["foo", "bar"].UT(:div, class: "bar") == "<div class=\"bar\">foobar</div>",
+		RETURN.is_a?(DomString),
+		["a", "b"].UT(:foo){|e| e * 2} == "<foo>aabb</foo>",
+		[["a", "b"], ["c", "d"]].UT(:bar, :foo){|e| e * 2} == "<foo><bar>aabb</bar><bar>ccdd</bar></foo>",
+	
+		"When the receiver that corresponds to the innermost tag is a string, the block is applied to it.",
+		<<~'RUBY'.code,
+			[["a", "b"], ["c", "d"]].dom(:td, :tr, :tbody){|e| e * 2} 
+			# => "<tbody><tr><td>aa</td><td>bb</td></tr><tr><td>cc</td><td>dd</td></tr></tbody>"
+		RUBY
+		[["a", "b"], ["c", "d"]].UT(:td, :tr, :tbody){|e| e * 2} == "<tbody><tr><td>aa</td><td>bb</td></tr><tr><td>cc</td><td>dd</td></tr></tbody>",
+	coda
+
+	hide spec "#jsonml",
+	coda
+end
+
+class File
+	spec ".relativize",
+		{"(string)" => String},
+		"Removes the initial slash if an absolute path is given. If a relative path is given, it has no effect.",
+		<<~'RUBY'.code,
+			File.relativize("/foo/bar/baz") #=> "foo/bar/baz"
+			File.relativize("foo/bar/baz") #=> "foo/bar/baz"
+		RUBY
+		UT("/foo/bar/baz") == "foo/bar/baz",
+		UT("foo/bar/baz") == "foo/bar/baz",
+	coda
+end