私家版REXML APIリファレンス

HOME > それいけ Ruby > XML > 私家版REXML APIリファレンス
Last modified: Fri Oct 31 10:54:03 +0900 2008

はじめに

このAPIリファレンスはREXML2.4.2のツリーAPIのもので、書 籍「Ruby de XML」の 付録として収録されているものをベースとしています。こ のAPIリファレンスはREXMLに付属してくるドキュメントと は別物です。ちなみに、REXML に付属してくるドキュメントの和訳のアーカイブはダウンロード出来ます。

まずはツリーAPIでのクラス、モジュールの構成を(Fig: ツリーAPIの構成)に示す。

Fig: ツリーAPIの構成

+-----------------+   +-----------------+   +--------------------------+
|  REXML::Child   |   |  REXML::Parent  |   |  REXML::Element          |  +-----------------+
|  _____________  |-+-|  _____________  |-+-|  ______________________  |--| REXML::Document |
| / REXML::Node \ | | | / Enumerable  \ | | | / REXML::Namespace     \ |  +-----------------+
| \_____________/ | | | \_____________/ | | | |  __________________  | |
+-----------------+ | +-----------------+ | | | / REXML::XMLTokens \ | |
                    |                     | | | \__________________/ | |
                    |                     | | \______________________/ |
                    |                     | +--------------------------+
                    |                     | +----------------------+
                    |                     | |  REXML::DocType      |
                    |                     +-|  __________________  |
                    |                       | / REXML::XMLTokens \ |
                    |                       | \__________________/ |
                    |                       +----------------------+
                    |
                    | +--------------------+
                    +-| REXML::Instruction |
                    | +--------------------+
                    | +-----------------+
                    | |  REXML::Comment |
                    +-|  _____________  |
                    | | / Comparable  \ |
                    | | \_____________/ |
                    | +-----------------+
                    | +-----------------+
                    | |  REXML::Text    | +--------------+
                    +-|  _____________  |-| REXML::CData |
                    | | / Comparable  \ | +--------------+
                    | | \_____________/ |
                    | +-----------------+
                    | +--------------------+
                    +-| REXML::XMLDecl     |
                    | +--------------------+
                    | +--------------------+ +--------------------+
                    +-| REXML::Declaration |-| REXML::ElementDecl |
                    | +--------------------+ +--------------------+
                    | +---------------------+
                    +-| REXML::NotationDecl |
                    | +---------------------+
                    | +----------------------+
                    | |  REXML::AttlistDecl  |
                    +-|  __________________  |
                    | | / REXML::XMLTokens \ |
                    | | \__________________/ |
                    | |  _________________   |
                    | | / Enumerable      \  |
                    | | \_________________/  |
                    | +----------------------+
                    | +----------------------+
                    | |  REXML::Entity       |
                    +-|  __________________  |
                      | / REXML::XMLTokens \ |
                      | \__________________/ |
                      +----------------------+
  _____________________
 / REXML::EntityConst  \
 \_____________________/
+----------------------+
|  REXML::Elements     |
|  __________________  |
| / Enumerable       \ |
| \__________________/ |
+----------------------+
+---------------------------------------------+
|  REXML::Attribute                           |
|                    ______________________   |
|                   / REXML::Namespace     \  |
|   _____________   |  __________________  |  |
|  / REXML::Node \  | / REXML::XMLTokens \ |  |
|  \_____________/  | \__________________/ |  |
|                   \______________________/  |
+---------------------------------------------+
+------+ +-------------------+
| Hash |-| REXML::Attributes |
+------+ +-------------------+

+---------+   ____________
| クラス  |  / モジュール \
+---------+  \____________/

(Fig: ツリーAPIの構成)の丸四角で囲まれたものがモジュールを表していて、 四角で囲まれたものがクラスを表している。クラスまたはモジュール中にモ ジュールが書かれているものはincludeされていることを表す。また、 線で結ばれているクラスは左にあるクラスが右にあるクラスのスーパークラス となる。

例えば、以下のような構成は(Fig: includeされたモジュール)の様に表す。

module A
end

class B
  include A
end

module C
  include A
end
Fig: includeされたモジュール

+-------+    _______
|   B   |   /   C   \
| _____ |   | _____ |
|/  A  \|   |/  A  \|
|\_____/|   |\_____/|
+-------+   \_______/

また、以下のような構成は(Fig: スーパークラス)の様に表す。

class A
end

class B < A
end
Fig: スーパークラス

+---+ +---+
| A |-| B |
+---+ +---+

REXML::Nodeモジュール

REXML::NodeモジュールREXML::ElementsクラスREXML::Attributesクラス以外のクラスでincludeされてお り、ツリーAPIのもっとも基本的な処理を定義している。

REXML::ElementsクラスREXML::AttributesクラスREXML::Nodeモジュールがincludeされていないのはこれ らのクラスがノードではなくノードセットを表現しているからだ。

各メソッドの例にはREXML::Nodeモジュールをincludeして いるREXML::Elementクラスのオブジェクトを用いる。また、以下 の記述は省略する。

source = "<root><a/><b/><c/></root>"
doc = REXML::Document.new(source)
REXML::Node#indent(to, ind)

toの末尾に&lt;&lt;メソッドでindで指定した分だけ空白を 追加する。もし、indが1より小さい場合は何もしない。

tmp = "tmp"
doc.root.indent(tmp, 3)
p tmp
# "tmp   "
tmp = "tmp"
doc.root.indent(tmp, 0)
p tmp
# "tmp"
REXML::Node#next_sibling_node

弟ノード(文書順で自分の次に現れる同じ親ノードを持つノード)を返す。 もし、親ノードが設定されていなかったり、弟ノードが無かったら nilを返す。

b = doc.elements["/root/b"]
puts b.next_sibling_node
# <c/>
puts b.next_sibling_node.next_sibling_node
# nil
REXML::Node#previous_sibling_node

兄ノード(逆文書順で自分の次に現れる同じ親ノードを持つノード)を返 す。もし、親ノードが設定されていなかったり、兄ノードが無かったら nilを返す。

b = doc.root.elements["b"]
puts b.previous_sibling_node
# <a/>
puts b.previous_sibling_node.previous_sibling_node
# nil
REXML::Node#to_s(indent=-1)

writeメソッドの第二引数にindentを指定したときに書き出 される文字列を返す。REXML::Nodeモジュールでは writeメソッドを定義しておらずincludeしているクラスで writeメソッドを定義している。

doc.root.write($stdout)
# <root><a/><b/><c/></root> ## putsで出力していないので改行はつかない
puts doc.root.to_s
# <root><a/><b/><c/></root>

REXML::XMLTokensモジュール

REXML::XMLTokensモジュールにはXML文書をパースするときに使 う定数が定義されている。

REXML::Namespaceモジュール

REXML::NamespaceモジュールREXML::XMLTokensモジュールをincludeしている。 REXML::Namespaceモジュールは ネームスペース関連に共通する処理を定義している。

各メソッドの例にはREXML::Namespaceモジュールを includeしているREXML::Elementクラスのオブジェクトを 用いる。また、以下の記述は省略する。

source = "<fuga:a xmlns:fuga='http://fuga/' xmlns:hoge='http://hoge'/>"
doc = REXML::Document.new(source)
REXML::Namespace#expanded_name

接頭辞付きの名前を返す。

puts doc.root.expanded_name
# fuga:a
REXML::Namespace#fully_expanded_name

REXML::Namespace#prefixメソッドで返される値と REXML::Namespace#nameメソッドで返される値を&quot;:&quot;で連結し た文字列を返す。必ずしもREXML::Namespace#expanded_name と等しい文字列を返すわけではない。

puts doc.root.expanded_name
# fuga:a
puts doc.root.fully_expanded_name
# fuga:a
doc.root.prefix = "hoge"
puts doc.root.expanded_name
# fuga:a
puts doc.root.fully_expanded_name
# hoge:a
REXML::Namespace#has_name?(name)

もし、nameが接頭辞付きの名前なら接頭辞付きで比較し、 nameが接頭辞のない名前なら接頭辞抜きの名前と比較する。常に接 頭辞付きで比較するわけではない。

puts doc.root.has_name?("fuga:a")
# true
puts doc.root.has_name?("hoge:a")
# false
puts doc.root.has_name?("a")
# true
REXML::Namespace#local_name

REXML::Namespace#nameメソッドの別名。

REXML::Namespace#name

接頭辞抜きの名前を返す。

puts doc.root.name
# a
REXML::Namespace#name=(name)

名前を設定する。

doc.root.name = "hoge:b"
puts doc.root.name
# b
puts doc.root.expanded_name
# hoge:b
puts doc.root.prefix
# hoge
REXML::Namespace#prefix

接頭辞を返す。

puts doc.root.prefix
# fuga
REXML::Namespace#prefix=(prefix)

接頭辞を設定する。

doc.root.prefix = "hoge"
puts doc.root.name
# hoge
puts doc.root.expanded_name
# fuga:a
puts doc.root.prefix
# hoge

REXML::Childクラス

REXML::ChildクラスREXML::ElementsクラスREXML::AttributesクラスREXML::Attributeクラス以外のクラスの祖先クラスになっており、 子ノードに共通する処理を定義している。

多くの場合、このクラスを直接使わず、このクラスを継承したクラスを使うこ とになる。

各メソッドの例にはREXML::Childクラスの(直接または間接的な) サブクラスであるREXML::TextクラスREXML::Elementクラス のオブジェクトを用いる。また、以下の記述は省略する。

source = "<root><a/><b/><c/></root>"
doc = REXML::Document.new(source)
REXML::Child.new(parent=nil)

parentを親ノードに設定する。

child = REXML::Child.new(doc.root)
puts child.parent.name
# root
child.parent = doc.root.elements["b"]
puts child.parent.name
# b
REXML::Child.once(*ids)

idsで指定された各シンボルと同じ名前を持つメソッドを一度しか 評価しなくする。つまり、一回 目の呼出し時に戻り値をキャッシュしておき、二回目以降の呼出しでは キャッシュされた値を返すようにする。

REXML::Child#bytes

to_sメソッドの結果を返す。特に理由が無ければto_sメソッ ドを使った方がよい。

REXML::Child#document

もし存在すれば自分自身が属するREXML::Documentクラスの オブジェクトを返す。存在しない場合はnilを返す。

puts doc.root.elements["b"].document
# <root><a/><b/><c/></root>
puts REXML::Text.new("abc").document
# nil
REXML::Child#next_sibling

REXML::Node#next_sibling_nodeメソッドの別名。

REXML::Child#next_sibling=(other)

otherを弟ノードとする。

puts doc.root.elements["b"].next_sibling = REXML::Text.new("abc")
# <root><a/><b/>abc<c/></root>
REXML::Child#parent

親ノードを返す。

例はREXML::Child.newメソッドを参照。

REXML::Child#parent=(other)

親ノードを設定する。

例はREXML::Child.newメソッドを参照。

REXML::Child#previous_sibling

REXML::Node#previous_sibling_nodeメソッドの別名。

REXML::Child#previous_sibling=(other)

otherを兄ノードとする。

puts doc.root.elements["b"].previous_sibling = REXML::Text.new("abc")
# <root><a/>abc<b/><c/></root>
REXML::Child#remove

自分自身を親ノードから取り除き、自分自身を返す。

puts doc.root.elements["b"].remove
# <b/>
puts doc.root
# <root><a/><c/></root>
REXML::Child#replace_with(child)

自分自身をchildで置き換え、自分自身を返す。

puts doc.root.elements["b"].replace_with(REXML::Text.new("abc"))
# <b/>
puts doc.root
# <root><a/>abc<c/></root>

REXML::Parentクラス

REXML::ParentクラスREXML::Childクラスのサブ クラスで、Enumerableモジュールをincludeしている。 REXML::Parentクラスは子ノードを持つことが出来るノード(つ まり親ノード)に共通の処理を提供する。

REXML::ParentクラスREXML::Childクラスと同様、 多くの場合このクラスを直接使わず、このクラスを継承したクラスを使うこと になる。

各メソッドの例にはREXML::Parentクラスのサブクラスである REXML::Elementクラスのオブジェクトを用いる。また、以下の記 述は省略する。

source = "<root><a/><b/><c/></root>"
doc = REXML::Document.new(source)
REXML::Parent.new(parent=nil)

parentを親ノードに設定する。

parent = REXML::Parent.new(doc.root)
puts parent.parent.name
# root
REXML::Parent#&lt;&lt;(object)

REXML::Parent#addメソッドの別名。

REXML::Parent#[index]

index番目の子ノードを返す。

puts doc.root[1]
# <b/>
REXML::Parent#[*args] = val

Array#[]=と同じ様に子ノードを代入する。戻り値は代入された子 ノード。

puts doc.root[1] = REXML::Element.new("d")
# <d/>
puts doc.root
# <root><a/><d/><c/></root>
REXML::Parent#add(object)

objectを最後の子ノードとして追加する。戻り値はobject

puts doc.root.add(REXML::Element.new("d"))
# <d/>
puts doc.root
# <root><a/><b/><c/><d/></root>
REXML::Parent#deep_clone

子ノードを含めたコピーを返す。

puts doc.root.deep_clone
# <root><a/><b/><c/></root>
REXML::Parent#delete(object)

もし、objectが子ノードなら削除する。子ノードでなければ何もし ない。戻り値はnil。

puts doc.root.delete(doc.root.elements["b"])
# nil
puts doc.root
# <root><a/><c/></root>
puts doc.root.delete("abc")
# nil
puts doc.root
# <root><a/><c/></root>
REXML::Parent#delete_at(index)

index番目の子ノードを削除する。何番目というのは1ではなく0か ら数え始める。つまり、最初の子ノードは0番目となる。戻り値は削除さ れたノード。

puts doc.root.delete_at(0)
# <a/>
puts doc.root
# <root><b/><c/></root>
REXML::Parent#delete_if(&amp;block)

ブロックが真を返す子ノードを削除する。戻り値は削除されなかった子ノー ドの配列。

p (doc.root.delete_if do |node|
     node.name == "b"
   end.collect {|node| node.to_s})
# ["<a/>", "<c/>"]
puts doc.root
# <root><a/><c/></root>
REXML::Parent#each(&amp;block)

各子ノード毎に、子ノードを引数にしてブロックを呼び出す。

tmp = []
doc.root.each {|node| tmp << node.to_s}
p tmp
# ["<a/>", "<b/>", "<c/>"]
REXML::Parent#each_child(&amp;block)

REXML::Parent#eachメソッドの別名。

REXML::Parent#each_index(&amp;block)

各子ノード毎に、子ノードのインデックスを引数にしてブロックを呼 び出す。

tmp = []
doc.root.each_index {|i| tmp << doc.root[i].to_s}
p tmp
# ["<a/>", "<b/>", "<c/>"]
REXML::Parent#index(child)

childが何番目の子ノードなのかを返す。もし、childが子ノー ドではない場合はREXML::Parent#sizeメソッドの戻り値-1を 返す。

puts doc.root.index(doc.root[1])
# 1
puts doc.root.index("abc")
# 2
REXML::Parent#insert_after(xpath, child)
REXML::Parent#insert_after(child1, child2)

REXML::Parent#insert_beforeメソッドとの違いは第二引数 を弟要素として設定することだけだ。

puts doc.root.insert_after("b", REXML::Element.new("d"))
# <root><a/><b/><d/><c/></root>
puts doc.root.insert_after(doc.root.elements["a"],
                            REXML::Element.new("e"))
# <root><a/><e/><d/><b/><c/></root>
puts doc.root.insert_after(doc.root, REXML::Element.new("f"))
# <root><a/><e/><d/><b/><c/><f/></root>
REXML::Parent#insert_before(xpath, child)
REXML::Parent#insert_before(child1, child2)

もし、第一引数がStringオブジェクトだったら一番目の形式になる。 この形式ではxpathにマッチするノードの兄ノードにchild を設定する。もし、xpathにマッチするノードがなかったり、マッ チしたノードがどの親ノードにも属していない場合は例外が発生する。

第一引数がStringオブジェクトでなかったら二番目の形式になる。 この形式ではchild2child1の兄ノードとして設定する。も し、child1が子ノードではなかったらchild2を最後の子ノー ドの兄ノードとして追加する。

戻り値は自分自身。

puts doc.root.insert_before("b", REXML::Element.new("d"))
# <root><a/><d/><b/><c/></root>
puts doc.root.insert_before(doc.root.elements["a"],
                            REXML::Element.new("e"))
# <root><e/><a/><d/><b/><c/></root>
puts doc.root.insert_before(doc.root, REXML::Element.new("f"))
# <root><e/><a/><d/><b/><f/><c/></root>
REXML::Parent#push(object)

REXML::Parent#addメソッドの別名。

REXML::Parent#replace_child(to_replace, replacement)

to_replacereplacementで置き換える。もし、 to_replaceが子ノードではない場合は例外が発生する。

puts doc.root.replace_child(doc.root.elements["b"], REXML::Element.new("d"))
# <root><a/><d/><c/></root>
REXML::Parent#size

子ノードの数を返す。

puts doc.root.size
# 3
REXML::Parent#to_a

子ノードの配列のコピーを返す。

p doc.root.to_a.collect {|node| node.to_s }
# ["<a/>", "<b/>", "<c/>"]
REXML::Parent#unshift(object)

objectを最初の子ノードとして追加する。戻り値は子ノードの配列。

p doc.root.unshift(REXML::Element.new("d")).collect{|node| node.to_s}
# ["<d/>", "<a/>", "<b/>", "<c/>"]
puts doc.root
# <root><d/><a/><b/><c/></root>

REXML::Elementクラス

REXML::ElementクラスREXML::Parentクラスのサ ブクラスであり、REXML::Namespaceモジュールをinclude している。このクラスは要素ノードを表現している。

ここでは、以下の記述は省略する。

source = <<-XML
<root>
 text1<![CDATA[cdata1]]>
 <a number='1'>a's text</a>
 <!--comment1-->
 <b number='2'/>
 text2<?pi1 content?>
 <c num='2'>c's text</c>
 <![CDATA[cdata2]]><!--comment2-->
 <?pi2 content?>
</root>
XML
doc = REXML::Document.new(source)
REXML::Element.new(source, parent=nil, context=nil)
REXML::Element.new(name=UNDEFINED, parent=nil, context=nil)
REXML::Element.new(element, parent=nil, context=nil)

第一引数がREXML::Sourceオブジェクトのときは一番目の形式にな る。この形式ではsourceをパースして要素名、属性、子ノードを設 定する。

第一引数がStringオブジェクトの場合は二番目の形式にな る。この形式では要素名をnameに設定する。現在、定数 REXML::Element::UNDEFINEDの値は&quot;UNDEFINED&quot;となっている。

第一引数がREXML::Elementクラスのオブジェクトの場合は elementの コピーを作る。属性はコピーされるが子ノードはコピーされない。

parentは親ノードになる。

contentはテキストノードの扱い方を指定する。

src = REXML::SourceFactory.create_from("<a attr='val'>text<b/></a>")
puts (e = REXML::Element.new(src))
# <a attr='val'>text<b/></a>
puts REXML::Element.new("child", e)
# <child/>
puts e
# <a attr='val'>text<b/><child/></a>
puts REXML::Element.new(e)
# <a attr='val'/>
REXML::Element#add_attribute(attribute)
REXML::Element#add_attribute(name, value=nil)

第一引数がREXML::Attributeクラスのオブジェクトなら一番 目の形式になる。 この形式ではattributeで指定された属性を追加する。もし、同じ 名前の属性が存在すれば上書きされる。

それ以外の場合は二番目の形式になる。nameで指定された属性名、 valueで指定された属性値をもつ属性を追加する。もし、同じ名前 の属性があった場合は上書きされる。もし、valueにnilを指 定した場合はnameで指定された属性名を持つ属性は削除される (REXMLのバグで削除されない場合もある)。

例はREXML::Element#has_attributes?メソッドを参照。

REXML::Element#add_attributes(hash_or_array)

HashまたはArrayオブジェクトで追加する属性を指定する。 形式は{属性名1 =&gt; 属性値1, 属性名2 =&gt; 属性値2, ...}または、 [[属性名1, 属性値1], [属性名2, 属性値2], ...]となる。

例はREXML::Element#has_attributes?メソッドを参照。

REXML::Element#add_element(element=nil, attrs=nil)

elementを最後の子ノードとして追加する。もし、attrsに {属性名 =&gt; 属性値}というハッシュを指定していたら elementにはattrsで指定した属性が追加される。

e = REXML::Element.new("a")
puts e.has_elements?
# false
puts e.add_element("b", {"attr" => "val"})
# <b attr='val'/>
puts e
# <a><b attr='val'/></a>
puts e.has_elements?
# true
puts e.delete_element("b")
# <b attr='val'/>
puts e.has_elements?
# false
puts e
# <a/>
REXML::Element#add_namespace(prefix, uri)
REXML::Element#add_namespace(uri)

一番目の形式では接頭辞がprefix、ネームスペース名がuri のネームスペース宣言を追加する。

二番目の形式ではネームスペース名がuriのデフォルトネームスペー ス宣言を追加する。

戻り値は自分自身。

例はREXML::Element#prefixesメソッドを参照。

REXML::Element#add_text(text)

textを最後の子ノードとして追加する。textに Stringオブジェクトを指定するとREXML::Textクラス のオブジェクトに変換される。

戻り値は自分自身。

puts doc.root.elements["a"].add_text("hoge")
# <a number='1'>a's texthoge</a>
puts doc.root.elements["b"].add_text("fuga")
# <b number='2'>fuga</b>
puts doc.root.elements["c"].add_text(nil)
# <c num='2'>c's text</c>
REXML::Element#attributes

属性を管理しているREXML::Attributesクラスのオブジェクトを返す。

REXML::Element#cdatas

子CDATAセクション(REXML::CDataクラスのオブジェクト) の配列を返す。 この配列は凍結されている。

p doc.root.cdatas.collect {|cdata| cdata.to_s }
# ["cdata1", "cdata2"]
puts doc.root.cdatas.frozen?
# true
REXML::Element#clone

コピーを返す。属性はコピーされるが子ノードはコピーされない。

puts doc.root.clone
# <root/>
REXML::Element#comments

子コメントノード(REXML::Commentクラスのオブジェクト) の配列を返す。 この配列は凍結されている。

p doc.root.comments.collect {|comment| comment.to_s }
# ["comment1", "comment2"]
puts doc.root.comments.frozen?
# true
REXML::Element#context

テキストノードの扱い方を取得する。

p doc.root.context
# {}
doc.root.context = {:compress_whitespace => :all}
p doc.root.context
# {:compress_whitespace=>:all}
REXML::Element#context=(context)

テキストノードの扱い方を設定する。

例はREXML::Element#contextメソッドを参照。

REXML::Element#delete_attribute(name)

nameで指定された属性名を持つ属性を削除する。

例はREXML::Element#has_attributes?メソッドを参照。

REXML::Element#delete_element(element)

与えれた引数でREXML::Elements#deleteメソッドを呼び出す。

例はREXML::Element#add_elementメソッドを参照。

REXML::Element#delete_namespace(prefix)
REXML::Element#delete_namespace

一番目の形式では接頭辞prefixのネームスペース宣言を削除する。

二番目の形式ではデフォルトネームスペース宣言を削除する。

戻り値は自分自身。

例はREXML::Element#prefixesメソッドを参照。

REXML::Element#document

自分自身が属するXML文書のルートノードを返す。

puts doc.elements["/root/b"].document.class
# REXML::Document
REXML::Element#each_element(xpath=nil, &amp;block)

与えれた引数でREXML::Elements#eachメソッドを呼び出す。

doc.root.each_element("*[@number]") {|elem| puts elem}
# <a number='1'>a&apos;s text</a>
# <b number='2'/>
doc.root.each_element {|elem| puts elem}
# <a number='1'>a&apos;s text</a>
# <b number='2'/>
# <c num='2'>c&apos;s text</c>
REXML::Element#each_element_with_attribute(key, value=nil, max=0, name=nil, &amp;block)

子孫ノードの中でkeyで指定された属性名を持つ要素を引数に ブロックを呼び出す。

valueを指定することによって属性値でフィルタがかけられる。

maxには最大で何回ブロックを呼び出 すかを指定する。maxに0以下の数値を指定するとブロックを呼 び出す回数に制限はかけられない。

nameにXPathを指定して検索す るノードセットを自分自身の子孫ノードセットからXPathにマッチする要 素の子孫ノードセットに変えることも出来る。

doc.root.each_element_with_attribute("number", "1") {|elem| puts elem}
# <a number='1'>a's text</a>
doc.root.each_element_with_attribute("number") {|elem| puts elem}
# <a number='1'>a's text</a>
# <b number='2'/>
REXML::Element#each_element_with_text(text=nil, max=0, name=nil, &amp;block)

REXML::Element#each_element_with_attributeメソッドと同 じく条件にあった要素を引数にブロックを呼び出す。

textにはブロックを呼び出したい要素の最初の子テキストノー ドの値を指定する。もし、textにnilを設定すると子テキス トノードが存在すればブロックが呼び出される。

doc.root.each_element_with_text("a's text") {|elem| puts elem}
# <a number='1'>a&apos;s text</a>
doc.root.each_element_with_text() {|elem| puts elem}
# <a number='1'>a&apos;s text</a>
# <c num='2'>c&apos;s text</c>
REXML::Element#elements

子要素を管理しているREXML::Elementsクラスのオブジェクトを返す。

REXML::Element#get_elements(xpath)

与えれた引数でREXML::Elements#to_aメソッドを呼び出す。

p doc.root.get_elements("*[@number]").collect{|elem| elem.to_s}
# ["<a number='1'>a&apos;s text</a>", "<b number='2'/>"]
REXML::Element#get_text(path=nil)

REXML::Element#textメソッドとの違いはテキストノードの内容で はなくてテキストノード、つまりREXML::Textクラスのオブ ジェクトを返すことだ。

p doc.root.get_text("a").to_s
# "a's text"
p doc.root.get_text.to_s
# "\n text1"
p doc.root.get_text("b")
# nil
REXML::Element#has_attributes?

属性が存在すれば真を返す。

e = REXML::Element.new("a")
puts e.has_attributes?
# false
puts e.add_attribute(REXML::Attribute.new("attr1", "val1"))
# <a attr1='val1'/>
puts e.add_attribute("attr2", "val2")
# <a attr1='val1' attr2='val2'/>
puts e.delete_attribute("attr1")
# <a attr2='val2'/>
puts e
# <a attr2='val2'/>
puts e.has_attributes?
# true
p e.add_attributes({"attr3" => "val3", "attr4" => "attr4"})
# {"attr3"=>"val3", "attr4"=>"attr4"}
puts e.delete_attribute("attr3")
# <a attr2='val2' attr4='attr4'/>
REXML::Element#has_elements?

子要素ノードを持っていれば真を返す。

例はREXML::Element#add_elementメソッドを参照。

REXML::Element#has_text?

子テキストノードが存在すれば真を返す。

puts doc.root.has_text?
# true
puts doc.root.elements["b"].has_text?
# false
REXML::Element#ignore_whitespace_nodes

空白のみのテキストノードをテキストノードとみなさないので あれば真を返す。このメソッドは REXML::Child.onceメソッドで一度しか評価されないように なっている。

e = REXML::Element.new("a")
puts e.ignore_whitespace_nodes
# nil
e = REXML::Element.new("a", nil, {:ignore_whitespace_nodes => %w(a)})
puts e.ignore_whitespace_nodes
# true
REXML::Element#instructions

子処理命令ノード(REXML::Instructionクラスのオブジェク ト)の配列を返す。 この配列は凍結されている。

p doc.root.instructions.collect {|instruction| instruction.to_s }
# ["<?pi1 content?>", "<?pi2 content?>"]
puts doc.root.instructions.frozen?
# true
REXML::Element#namespace(prefix=nil)

prefixに関連付けられているネームスペース名を返す。もし、 prefixが省略された場合は要素名についている接頭辞が指定された ものとみなされる。prefixが省略されて、要素名に接頭辞が指定さ れていない場合はデフォルトネームスペース名が返される。明示的にデフォ ルトネームスペース名を取得したいときはprefixに空文字列を指定 する。

例はREXML::Element#prefixesメソッドを参照。

REXML::Element#next_element

弟要素を返す。もし、弟要素が無ければnilを返す。

b = doc.root.elements["b"]
puts b.next_element
# <c num='2'>c&apos;s text</c>
puts b.next_element.next_element
# nil
REXML::Element#prefixes

この要素で有効な接頭辞を配列で返す。

e = REXML::Element.new("a")
puts e.add_namespace("fuga", "http://fuga/")
# <a xmlns:fuga='http://fuga/'/>
puts e.add_namespace("http://hoge/")
# <a xmlns:fuga='http://fuga/' xmlns='http://hoge/'/>
p e.prefixes
# ["fuga"]
puts e.namespace("fuga")
# http://fuga/
puts e.namespace
# http://hoge/
puts e.delete_namespace("fuga")
# <a xmlns='http://hoge/'/>
puts e.delete_namespace
# <a/>
REXML::Element#previous_element

兄要素を返す。もし、兄要素が無ければnilを返す。

b = doc.root.elements["b"]
puts b.previous_element
# <a number='1'>a&apos;s text</a>
puts b.previous_element.previous_element
# nil
REXML::Element#raw

テキストノードの値を展開しないモード(rawモード)ならば真を返す。 このメソッドはREXML::Child.onceメソッドで一度しか評価されな いようになっている。

e = REXML::Element.new("a")
puts e.raw
# nil
e = REXML::Element.new("a", nil, {:raw => %w(a)})
puts e.raw
# true
REXML::Element#root

自分自身が属するXML文書のルート要素を返す。

puts doc.elements["/root/a"].root.name
# root
REXML::Element#text(path=nil)

pathにマッチする要素の最初の子テキストノードの内容を返す。も し、pathが省略されたら自分自身の最初の子テキストノードの内容 を返す。もし、子テキストノードが存在しない場合はnilを返す。

p doc.root.text("a")
# "a's text"
p doc.root.text
# "\n text1"
p doc.root.text("b")
# nil
REXML::Element#text=(text)

最初の子テキストノードをtextで置き換える。textに Stringオブジェクトを指定するとREXML::Textクラス のオブジェクトに変換される。 もし、子テキストノードを持たない場合はtextを最後の子ノードと して追加する。textにnilを指定した場合は最初の子テキス トノードを削除する。

戻り値は自分自身。

puts doc.root.elements["a"].text = "hoge"
# <a number='1'>hoge</a>
p doc.root.elements["a"].text
# "hoge"
puts doc.root.elements["b"].text = "fuga"
# <b number='2'>fuga</b>
p doc.root.elements["b"].text
# "fuga"
puts doc.root.elements["c"].text = nil
# <c num='2'/>
p doc.root.elements["c"].text
# nil
REXML::Element#texts

子テキストノード(REXML::Textクラスのオブジェクト)の 配列を返す。 この配列は凍結されている。

p doc.root.texts.collect {|text| text.to_s }
# ["\n text1", "cdata1", "\n ", "\n ", "\n ",
#  "\n text2", "\n ", "\n ", "cdata2", "\n ", "\n"]
puts doc.root.texts.frozen?
# true
REXML::Element#whitespace

空白をそのまま扱うなら真を返す。このメソッドは REXML::Child.onceメソッドで一度しか評価されないように なっている。

e = REXML::Element.new("a")
puts e.whitespace
# true
e = REXML::Element.new("a", nil, {:compress_whitespace => %w(a)})
puts e.whitespace
# false
REXML::Element#write(output, indent=-1, transitive=false)

outputに要素の内容(子孫ノードを含む)を書き出す。

indentに1以上の数値を指定するとインデント付きで書き出される。

もし、transitiveがtrueなら、テキストノードに(インデン トのための)余分な空白は含まれない。

doc.root.write($stdout, 4, true)
# <root>
#  text1      <![CDATA[cdata1]]>
#  <a number='1'>a's text</a
#       >
#        <!--comment1-->
#  <b number='2'/
#       >
#  text2      <?pi1 content?>
#  <c num='2'>c's text</c
#       >
#        <![CDATA[cdata2]]>      <!--comment2-->
#        <?pi2 content?>
# </root
#   >

REXML::Documentクラス

REXML::DocumentクラスREXML::Elementクラスの サブクラスで、XML文書のルートを表現している。

ここでは、以下の記述は省略する。

source = "<root/>"
doc = REXML::Document.new(source)
REXML::Document.new(source=nil, context={})

sourceにはREXML::Source、 REXML::Document、String、IOオブジェクトのいずれ かを指定する。

もし、 REXML::Documentクラスのオブジェクトが指定された ときはコピーが生成される。ただし、子ノードまではコピーされないので 空のXML文書(ルート要素すらない)が作成される。

もし、StringまたはIOオブジェクトが指定された時は REXML::SourceまたはREXML::IOSourceオブジェクトが生成さ れREXML::Sourceオブジェクトが指定されたときと同じ様に処理さ れる。

もし、REXML::Sourceオブジェクトが指定されたときは sourceの内容がパースされXMLツリーを構築する。

contextにはテキストノードの扱い方を指定する。

puts REXML::Document.new(source)
# <root/>
REXML::Document#&lt;&lt;(child)

REXML::Document#addの別名。

REXML::Document#add(child)

childを最後の子ノードとして追加する。

もし、childREXML::XMLDeclクラスのオブジェクト なら最初の子ノードとして追加する。

もし、childREXML::DocTypeクラスのオブジェクトなら REXML::XMLDeclクラスのオブジェクトの次のノードとして追 加する(子ノードセット中にREXML::XMLDeclクラスのオブジェ クトが存在しない場合は最初の子ノードとして追加する)。

ノードを追加した結果ルート要素が二つ以上になると例外が発生する。

puts doc.add(REXML::DocType.new("root"))
# <!DOCTYPE root>
puts doc
# <!DOCTYPE root><root/>
REXML::Document#add_element(element=nil, attrs=nil)

REXML::Element#add_elementメソッドと同じ。ただし、要素 を追加した結果ルート要素が二つ以上になると例外が発生する。

puts doc.add_element("root2")
# 例外発生
REXML::Document#clone

コピーを返す。ただし、子ノードまではコピーされないので空のXML文書 (ルート要素すらない)が作成される。

p doc.clone.to_s
# ""
REXML::Document#doc_type

REXML::DocTypeクラスのオブジェクトを返す。もし、 DOCTYPE宣言がされていなければnilを返す。

puts doc.doc_type
# nil
REXML::Document#encoding

XML宣言のencodingの値を返す。もし、XML宣言がされていなければ REXML::Document::DECLARATION.encodingメソッドの戻り値を返す。 この値は現在のところ&quot;UTF-8&quot;だ。

puts doc.encoding
# UTF-8
REXML::Document#expanded_name

空文字列を返す。

p doc.expanded_name
# ""
REXML::Document#name

REXML::Document#expanded_nameの別名。

REXML::Document#root

ルート要素を返す。ルート要素が無ければnilを返す。

puts doc.root
# <root/>
REXML::Document#stand_alone?

XML宣言のstandaloneの値を返す。もし、XML宣言がされていなければ REXML::Document::DECLARATION.stand_alone?メソッドの戻り値を返す。 この値は現在のところnilだ。

puts doc.stand_alone?
# nil
REXML::Document#version

XML宣言のversionの値を返す。もし、XML宣言がされていなければ REXML::Document::DECLARATION.versionメソッドの戻り値を返す。 この値は現在のところ&quot;1.0&quot;だ。

puts doc.version
# 1.0
REXML::Document#write(output, indent=-1, transitive=false)

outputにXML文書を書き出す。outputindenttransitiveの値は各子ノードのwriteメソッドに渡される。

doc.write($stdout)
# <root/>
REXML::Document#xml_decl

REXML::XMLDeclクラスのオブジェクトを返す。もし、XML宣 言がされていな ければ定数REXML::Document::DECLARATIONを返す。この定数には REXML::XMLDeclクラスのオブジェクトが設定されている。

puts doc.xml_decl
# <?xml version='1.0' encoding='UTF-8'?>

REXML::Instructionクラス

REXML::InstructionクラスREXML::Childクラスの サブクラスで処理命令ノードを表現している。

ここでは、以下の記述は省略する。

pi = REXML::Instruction.new("pi", "content")
REXML::Instruction.new(source, parent=nil)
REXML::Instruction.new(instruction, parent=nil)
REXML::Instruction.new(target, content=nil)

第一引数がREXML::Sourceオブジェクトなら一番目の形式になる。 この形式ではsourceをパースして処理命令ノードを取りだす。 parentには親ノードを指定する。

第一引数がREXML::Instructionクラスのオブジェクトなら二 番目の形式になる。この形式ではinstructionのコピーを作る。 parentには親ノードを指定する。

第一引数がStringオブジェクトなら三番目の形式になる。この形式 ではtargetにターゲット名を、contentに内容を 指定する。

e = REXML::Element.new("parent")
puts REXML::Instruction.new(pi, e)
# <?pi content?>
puts e
# <parent><?pi content?></parent>
REXML::Instruction#==(other)

otherREXML::Instructionクラスのオブジェクトで、 ターゲット名、内容共に等しいとき真を返す。

puts pi == pi.clone
# true
REXML::Instruction#clone

コピーを返す。

puts pi.clone
# <?pi content?>
REXML::Instruction#content

内容を返す。

puts pi.content
# content
p pi.content = "new content"
# "new content"
p pi.content
# "new content"
REXML::Instruction#content=(content)

内容を設定する。

例はREXML::Instruction#contentメソッドを参照。

REXML::Instruction#target

ターゲット名を返す。

puts pi.target
# pi
puts pi.target = "pi_new"
# pi_new
puts pi.target
# pi_new
REXML::Instruction#target=(target)

ターゲット名を設定する。

例はREXML::Instruction#targetメソッドを参照。

REXML::Instruction#write(output, indent=-1)

indentで指定した分だけインデントをつけてoutputに処理命 令を書き出す。

tmp = ""
pi.write(tmp, 3)
p tmp
# "   <?pi content?>"

REXML::Commentクラス

REXML::CommentクラスREXML::Childクラスのサブ クラスでComparableモジュールをincludeしている。このクラス はコメントノードを表現する。

ここでは、以下の記述は省略する。

comment = REXML::Comment.new("comment")
REXML::Comment.new(string, parent=nil)
REXML::Comment.new(comment, parent=nil)
REXML::Comment.new(source, parent=nil)

第一引数がStringオブジェクトなら一番目の形式となる。この形式 ではstringがコメントの内容となる。

第一引数がREXML::Commentクラスのオブジェクトならコピー を作成する。

第一引数がREXML::Sourceオブジェクトならsourceをパース してREXML::Commentクラスのオブジェクトを生成する。

parentは親ノードになる。

e = REXML::Element.new("parent")
REXML::Comment.new(comment, e)
puts e
# <parent><!--comment--></parent>
REXML::Comment#clone

コピーを返す。

puts comment.clone
# comment
REXML::Comment#string

コメントの内容を返す。

p comment.string
# "comment"
p comment.string = "new comment"
# "new comment"
p comment.to_s
# "new comment"
REXML::Comment#string=(new_comment)

コメントの内容をnew_commentにする。

例はREXML::Comment#stringメソッドを参照。

REXML::Comment#to_s

REXML::Comment#stringの別名。

例はREXML::Comment#stringメソッドを参照。

REXML::Comment#write(output, indent=-1)

indentで指定した分だけインデントをつけてoutputにコメン トを書き出す。

tmp = ""
comment.write(tmp, 3)
p tmp
# "   <!--comment-->"

REXML::Textクラス

REXML::TextクラスREXML::Childクラスのサブク ラスでComparableモジュールをincludeしている。このクラスは テキストノードを表現する。

ここでは、以下の記述は省略する。

text = REXML::Text.new("text")
REXML::Text.new(raw, dummy=nil, parent=nil)
REXML::Text.new(text, dummy=nil, parent=nil)
REXML::Text.new(string, respect_whitespace=false, parent=nil)
REXML::Text.new(source, respect_whitespace=false, parent_or_raw=nil)

第一引数がtrueまたはfalseの場合は一番目の形式となる。 この形式では、rawに参照を展開しないかどうか(参照を展開し ないならtrueするならfalse)を、parentに親ノード を指定する。

第一引数がREXML::Textクラスのオブジェクトなら二番目の 形式となる。こ の形式はtextのコピーを作る。parentには親ノードを指 定する。

第一引数がStringオブジェクトなら三番目の形式となる。この形式 ではstringがテキストの内容となる。ただし、stringは参照 が展開されたものとみなされる。もし、 respect_whitespaceにfalseが指定されていればテキスト内 の連続した空白文字(&apos; &apos;、&apos;\t&apos;、&apos;\n&apos;)は単一の空白文字に置き換わる。 parentには親ノードを指定する。

第一引数がSourceオブジェクトなら四番目の形式となる。この形式 ではsourceをパースしてテキストの内容を設定する。もし、 respect_whitespaceにfalseが指定されていればテキスト内 の連続した空白文字(&apos; &apos;、&apos;\t&apos;、&apos;\n&apos;)は単一の空白文字に置き換わる。 もし、parent_or_rawにtrueを指定した場合は参照を展開し なくなる。REXML::Parentクラスのオブジェクトを指定した 場合はparent_or_rawが親ノードになる。

e = REXML::Element.new("parent")
REXML::Text.new(text, nil, e)
puts e
# <parent>text</parent>
p REXML::Text.new("   has  some \t\t  \n\n  spaces   ").to_s
# " has some \t \n spaces "
p REXML::Text.new("   has  some \t\t  \n\n  spaces   ", true).to_s
# "   has  some \t\t  \n\n  spaces   "
REXML::Text.normalize(input, doctype=nil)

doctype.entitiesで得られる{実体名 =&gt; REXML::Entityオブジェ クト}というハッシュをもとに、input内の実体の内 容を実体参照に変換した文字列を返す。doctypeを省略した場合は 定数REXML::DocType::DEFAULT_ENTITIESが用いられる。

puts REXML::Text.normalize("<")
# &lt;
REXML::Text.unnormalize(string, doctype=nil)

doctype.entity(実体名)で返される実体の内容をもとに stringの数値参照、実体参照を展開した文字列を返す。 doctypeが省略された場合は定数 REXML::DocType::DEFAULT_ENTITIESが用いられる。

puts REXML::Text.unnormalize("&lt;")
# <
REXML::Text#clone

コピーを返す。

puts text.clone
# text
REXML::Text#empty?

テキストの内容が無ければ真を返す。

puts text.empty?
# false
REXML::Text#raw

内容中の参照が展開されるならfalseを返す。

text_ref = REXML::Text.new("&lt;")
t = text_ref.clone
# REXML::Text.newの第一引数にStringオブジェクトを指定すると参照が
# 展開されたものと見なされるので、REXML::Text#cloneメソッドを
# 使ってREXML::Textオブジェクトを作り直す。
puts t.raw
# false
puts t.string
# &lt;
puts t.to_s
# <
t = text_ref.clone
puts t.raw = true
# true
puts t.string
# &lt;
puts t.to_s
# &lt;
REXML::Text#raw=(raw)

falseを指定すると、もし、内容中の参照が展開されていなければ 展開されるようになる。

例はREXML::Text#rawメソッドを参照。

REXML::Text#string

テキストの内容を返す(参照が展開されているかもしれないしされていな いかもしれない)。

例はREXML::Text#rawメソッドを参照。

REXML::Text#to_s

REXML::Text#rawメソッドがfalseを返すなら参照が展 開されたテキストの内容を返す。

例はREXML::Text#rawメソッドを参照。

REXML::Text#write(output)

outputにテキストの内容を書き出す。

text.write($stdout)
# text

REXML::CDataクラス

REXML::CDataクラスREXML::Textクラスのサブク ラスでCDATAセクションを表す。

ここでは、以下の記述は省略する。

cdata = REXML::CData.new("cdata")
REXML::CData.new(first, whitespace=nil, parent=nil)

REXML::Text.newメソッドと同じ。

e = REXML::Element.new("parent")
REXML::CData.new(cdata, nil, e)
puts e
# <parent><![CDATA[cdata]]></parent>
REXML::CData#clone

コピーを返す。

puts cdata.clone
# cdata
REXML::CData#to_s

CDATAセクションの内容を返す。

puts cdata.to_s
# cdata
REXML::CData#write(output, indent=-1)

indentで指定した分だけインデントをつけてoutputにCDATA セクションを出力する。

tmp = ""
cdata.write(tmp, 3)
p tmp
# "   <![CDATA[cdata]]>"

REXML::XMLDeclクラス

REXML::XMLDeclクラスREXML::Childクラスのサブ クラスで、XML宣言を表現している。

ここでは、以下の記述は省略する。

xml_decl = REXML::XMLDecl.new("1.0", "UTF-8", "no")
REXML::XMLDecl.new(source, parent=nil)
REXML::XMLDecl.new(xmldecl)
REXML::XMLDecl.new(version=DEFAULT_VERSION, encoding=nil, standalone=nil)

第一引数にREXML::Sourceオブジェクトが指定したときは一番目 の形式になる。この形式ではsourceをパースしてバージョン、エ ンコーディング、スタンドアロンの値を取得する。 parentには親ノードを指定する。

第一引数にREXML::XMLDeclクラスのオブジェクトを指定した ときは二番目の 形式になる。この形式ではxmldeclのコピーを生成する。ただし、 親ノードまではコピーされない。

それ以外の場合は三番目の形式になる。この形式ではバージョンを versionに、エンコーディングをencodingに、スタンドアロン をstandaloneに設定する。現在は 定数REXML::XMLDecl::DEFAULT_VERSIONの値は&quot;1.0&quot;となって いる。

puts REXML::XMLDecl.new(xml_decl)
# <?xml version='1.0' encoding='UTF-8' standalone='no'?>
REXML::XMLDecl#==(other)

otherREXML::XMLDeclクラスのオブジェクトであり、 バージョン、エンコーディング、スタンドアロンの全てが等しければ 真を返す。

puts xml_decl == xml_decl.clone
# true
REXML::XMLDecl#clone

コピーを返す。

puts xml_decl.clone
# <?xml version='1.0' encoding='UTF-8' standalone='no'?>
REXML::XMLDecl#encoding

エンコーディングを返す。エンコーディングはREXML内部で大文字 に変換されるので、小文字を設定しても返ってくるのは大文字になる。

puts xml_decl.encoding
# UTF-8
xml_decl.encoding = "EUC-JP"
puts xml_decl.encoding
# nil
REXML::XMLDecl#encoding=(encoding)

エンコーディングを設定する。このとき、encoding の値は大文字に変換される。ただし、 encodingが大文字小文字を区別せず&quot;iso-8859-1&quot;、&quot;utf-8&quot;、 &quot;unile&quot;、&quot;utf-16&quot;以外の値であれば設定しない。

例はREXML::XMLDecl#encodingメソッドを参照。

REXML::XMLDecl#stand_alone?

REXML::XMLDecl#standaloneメソッドの別名。

例はREXML::XMLDecl#standaloneメソッドを参照。

REXML::XMLDecl#standalone

スタンドアロンを返す。

puts xml_decl.standalone
# no
xml_decl.standalone = "yes"
puts xml_decl.stand_alone?
# yes
REXML::XMLDecl#standalone=(standalone)

スタンドアロンを設定する。

例はREXML::XMLDecl#standaloneメソッドを参照。

REXML::XMLDecl#version

バージョンを返す。

puts xml_decl.version
# 1.0
xml_decl.version = "1.1"
puts xml_decl.version
# 1.1
REXML::XMLDecl#version=(version)

バージョンを設定する。

例はREXML::XMLDecl#versionメソッドを参照。

REXML::XMLDecl#write(output, indent=-1)

outputにXML宣言を書き込む。 indentに1以上の数値を指定すると、XML宣言を書き込む前の outputREXML::Node#indentメソッドを使ってインデ ントを設定する。

tmp = ""
xml_decl.write(tmp, 3)
p tmp
# "   <?xml version='1.0' encoding='UTF-8' standalone='no'?>"
REXML::XMLDecl#xmldecl(version, encoding, standalone)

バージョンをversionに、エンコーディングをencodingに、 スタンドアロンをstandaloneに設定する。エンコーディングの設 定にはREXML::XMLDecl#encoding=メソッドが用いられる。

puts xml_decl
# <?xml version='1.0' encoding='UTF-8' standalone='yes'?>
xml_decl.xmldecl("1.1", "utf-16", nil)
puts xml_decl
# <?xml version='1.1' encoding='UTF-16'?>

REXML::DocTypeクラス

REXML::DocTypeクラスREXML::Parentクラスのサ ブクラスでREXML::XMLTokensモジュールをincludeしている。こ のクラスはDOCTYPE宣言を表現している。

ここでは、以下の記述は省略する。

doc_type = REXML::DocType.new("hoge", "SYSTEM 'hoge.dtd'")
REXML::DocType.new(name, external_id=nil)
REXML::DocType.new(doctype, parent=nil)
REXML::DocType.new(source, parent=nil)

第一引数がStringオブジェクトだった場合は一番目の形式になる。 この形式では、&lt;!DOCTYPE hoge SYSTEM &quot;hoge.dtd&quot;&gt;というDOCTYPE宣言が あったらnameには&quot;hoge&quot;を、external_idには&quot;SYSTEM hoge.dtd&quot;を指定する。そうではなくて、&lt;!DOCTYPE hoge [ ... ]&gt;という DOCTYPE宣言だったら、nameには&quot;hoge&quot;を、external_idには nilを指定する。

第一引数がREXML::DocTypeクラスのオブジェクトだった場合 は二番目の形式 になる。この形式ではdoctypeのコピーを生成する。ただし、親ノー ドはコピーされずparentで指定したノードになる。

第一引数がREXML::Sourceオブジェクトの場合は三番目の形式にな る。この形式ではsourceがパースされ、DOCTYPE宣言内のノード (ENTITY宣言等の宣言やコメントノード等)が子ノードに設定される。

puts REXML::DocType.new("hoge")
# <!DOCTYPE hoge>
doc = REXML::Document.new
REXML::DocType.new(doc_type, doc)
puts doc
# <!DOCTYPE hoge SYSTEM 'hoge.dtd'>
REXML::DocType#add(child)

childを最後の子ノードとして追加する。

例はREXML::DocType#attribute_ofメソッドを参照。

REXML::DocType#attribute_of(element, attribute)

elementで指定された要素名のATTLIST宣言された属性のうち attributeで指定された属性名を持つ属性のデフォルトの属性値を 返す。もし、デフォルト値が設定されていなければnilを返す。

doc_type = REXML::DocType.new("hoge")
doc_type.add(REXML::Entity.new("name", "value"))
puts doc_type.entity("name")
# value
puts doc_type.entities["lt"]
# <!ENTITY lt "<">
REXML::DocType#attributes_of(element)

elementで指定された要素名のATTLIST宣言された属性 (REXML::Attributeクラスのオブジェクト)の配列を返す。

source = REXML::SourceFactory.create_from(<<-DOCTYPE)
<!DOCTYPE hoge [
<!ATTLIST fuga 
          id      ID      #REQUIRED
          attr    CDATA   #IMPLIED>
<!ATTLIST foo
          attr    CDATA   "xyz">
]>
DOCTYPE
doc_type = REXML::DocType.new(source)
p doc_type.attributes_of("fuga").collect{|attr| attr.class}
# [REXML::Attribute, REXML::Attribute]
p doc_type.attribute_of("foo", "attr")
# "xyz"
REXML::DocType#clone

コピーを返す。

puts doc_type.clone
# <!DOCTYPE hoge SYSTEM 'hoge.dtd'>
REXML::DocType#entities

{実体名 =&gt; 実体(REXML::Entityオブジェクト)}というハッ シュを返す。

例はREXML::DocType#attribute_ofメソッドを参照。

REXML::DocType#entity(name)

XMLの仕様書で定義された実体または、ENTITY宣言で定義された実体のう ちnameで指定された実体名を持つ実体の内容を返す。もし、実体が 定義されていなければnilを返す。

例はREXML::DocType#attribute_ofメソッドを参照。

REXML::DocType#external_id

通常は&quot;PUBLIC ...&quot;か&quot;SYSTEM ...&quot;かnilを返す。

puts doc_type.external_id
# SYSTEM 'hoge.dtd'
REXML::DocType#name

DOCTYPE宣言で指定されたルート要素の名前を返す。

puts doc_type.name
# hoge
REXML::DocType#write(output, indent=0)

indentで指定されたインデントでoutputにDOCTYPE宣言を書 き出す。

tmp = ""
doc_type.write(tmp, 3)
p tmp
# "   <!DOCTYPE hoge SYSTEM 'hoge.dtd'>"

REXML::Declarationクラス

REXML::DeclarationクラスではDOCTYPE宣言内の各種宣言 (ATTLIST宣言やENTITY宣言等)で共通する処理を定義している。しかし、現 在のバージョンではREXML::ElementDeclクラス(ELEMENT宣言を 表現しているクラス)だけのスーパークラスとなっている。 (注1)

(注1) 以前のバージョ ンではREXML::AttlistDeclクラスのスーパークラスでもあった。

このクラスを直接使うことは無いと思うので例は省略する。

REXML::Declaration.new(source)

sourceから宣言の内容を取りだす。

REXML::Declaration#to_s

宣言の内容を返す。

REXML::Declaretion#write(output, indent)

indentで指定された数値×3個の空白付きでoutputに 宣言の内容を書き出す。

REXML::ElementDeclクラス

REXML::ElementDeclクラスREXML::DeclarationクラスのサブクラスでELEMENT宣言を表現している。

このクラスを直接使うことは無いと思うので例は省略する。

REXML::ElementDecl#pattern

ELEMENT宣言の構文にマッチする正規表現を返す。このメソッドは REXML::Declaration.newメソッドで使われる。

REXML::NotationDeclクラス

REXML::NotationDeclクラスREXML::Childクラス のサブクラスでNOTATION宣言を表現している。

このクラスを直接使うことは無いと思うので例は省略する。

REXML::NotationDecl.new(source)

sourceからNOTATION宣言の内容を取りだす。

REXML::NotationDecl#to_s

NOTATION宣言を返す。

REXML::NotationDecl#write(output, indent=-1)

indentで指定された数値×3個の空白付きでoutputに NOTATION宣言を書き出す。

REXML::AttlistDeclクラス

REXML::AttlistDeclクラスREXML::Childクラスの サブクラスで、REXML::XMLTokensモジュールとEnumerable モジュールをincludeしている。このクラスはATTLIST宣言を表現してい る。

このクラスを直接使うことは無いと思うので例は省略する。

REXML::AttlistDecl.new(source)

sourceからATTLIST宣言の内容を取りだす。

REXML::AttlistDecl#[key]

keyという属性名の属性値にデフォルト値が設定されていればそれ を返す。設定されていなければnilを返す。

REXML::AttlistDecl#element

対象となる要素名を返す。

REXML::AttlistDecl#include?(key)

keyという属性名の属性値にデフォルト値が設定されていれば真を 返す。

REXML::AttlistDecl#write(output)

outputにATTLIST宣言を書き出す。

REXML::Entityクラス

REXML::EntityクラスREXML::Childクラスのサブ クラスでREXML::XMLTokensモジュールをincludeしている。 このクラスは実体を表現している。

ここでは、以下の記述は省略する。

entity = REXML::Entity.new("hoge", "1 &lt;&#x3d; 3")
REXML::Entity.new(name, value=nil, parent=nil)
REXML::Entity.new(source, dummy=nil, parent=nil)

第一引数がStringオブジェクトなら一番目の形式になる。 nameには実体名を、valueには実体の内容を指定する。

第一引数がREXML::Sourceオブジェクトなら sourceからENTITY宣言を取りだす。

parentには親ノードを指定する。

puts REXML::Entity.new("fuga", "fuga fuga")
# <!ENTITY fuga "fuga fuga">
REXML::Entity#external

&quot;SYSTEM&quot;か&quot;PUBLIC&quot;かnilを返す。

puts entity.external
# nil
REXML::Entity#name

実体名を返す。

puts entity.name
# hoge
REXML::Entity#ndata

記法を返す。

puts entity.ndata
# nil
REXML::Entity#normalized

参照が展開されていない実体の内容を返す。

p entity.normalized
# "1 &lt;&#x3d; 3"
REXML::Entity#pubid

公開識別子を返す。

puts entity.pubid
# nil
REXML::Entity#ref

システム識別子を返す。

puts entity.ref
# nil
REXML::Entity#to_s

REXML::Entity#writeメソッドで書き出す文字列を返す。

puts entity.to_s
# <!ENTITY hoge "1 &lt;&#x3d; 3">
REXML::Entity#unnormalized

パラメータ実体参照、一般実体参照、数値 参照を展開した実体の内容を返す。

p entity.unnormalized
# "1 <= 3"
REXML::Entity#value

パラメータ実体参照を展開した実体の内容を返す(はず)。

p entity.value
# "1 &lt;&#x3d; 3"
REXML::Entity#write(output)

outputにENTITY宣言を書き出す。

entity.write($stdout)
# <!ENTITY hoge "1 &lt;&#x3d; 3">

REXML::EntityConstモジュール

REXML::EntityConstモジュールにはXMLの仕様書で定められた実 体(gt やlt)が定義されている。

REXML::Elementsクラス

REXML::ElementsクラスはEnumerableモジュールを include していて、REXML::Elementクラスで子要素を管理 するために使われている。主にREXML::Element#elementsメソッ ドでアクセスすることになるだろう。

ここでは、以下の記述は省略する。

source = "<root><a num='1'/><a num='2'/><b/><c/></root>"
doc = REXML::Document.new(source)
elems = doc.root.elements
REXML::Elements.new(parent)

parentを親要素に設定する。

REXML::Elements#&lt;&lt;(element=nil)

REXML::Elements#addメソッド別名。

REXML::Elements#[index, name=nil]
REXML::Elements#[xpath]

第一引数にIntegerオブジェクトを指定したときは一番目の形式に なる。この形式では、nameという要素名を持つindex番目の 要素を返す。もし、nameが省略された場合は子要素の中の index番目の要素を返す。注意して欲しいのが何番目の要素という のは0ではなく1から始まるということだ。indexに1より小さい 数値を指定すると例外が発生する。

二番目の形式ではxpathに最初にマッチした子要素を返す。

どちらの形式でも指定された要素が見つからない場合はnilを返す。

puts elems[1, "a"]
# <a num='1'/>
puts elems["b"]
# <b/>
REXML::Elements#[index] = element

indexを引数にREXML::Elements#[]メソッドを呼び出 した結果返ってきた要素をelementで置き換える。もし、 REXML::Elements#[]がnilを返したらelementを 最後の子要素として追加する。

elems[1] = REXML::Element.new("d")
puts doc.root
# <root><d/><a num='2'/><b/><c/></root>
elems[100] = REXML::Element.new("e")
puts doc.root
# <root><d/><a num='2'/><b/><c/><e/></root>
REXML::Elements#add(element=nil)

elementを最後の子要素として追加する。もし、elementを省 略すると要素名の無い要素を作ってしまうので注意して欲しい。

puts elems.add(REXML::Element.new("d"))
# <d/>
puts doc.root
# <root><a num='1'/><a num='2'/><b/><c/><d/></root>
puts elems.add
# </>
puts doc.root
# <root><a num='1'/><a num='2'/><b/><c/><d/></></root>
REXML::Elements#delete(element)

elementを子要素から削除する。elementには REXML::Elementクラスのオブジェクト、要素名、何番目の要 素かのいずれかを指定できる。

puts elems.delete(1)
# <a num='1'/>
puts doc.root
# <root><a num='2'/><b/><c/></root>
puts elems.delete("b")
# <b/>
puts doc.root
# <root><a num='2'/><c/></root>
REXML::Elements#delete_all(xpath)

xpathにマッチする全ての要素を削除する。戻り値は削除された要 素の配列。

p elems.delete_all("a").collect {|elem| elem.to_s}
# ["<a num='1'/>", "<a num='2'/>"]
puts doc.root
# <root><b/><c/></root>
REXML::Elements#each(xpath=nil, &amp;block)

xpathにマッチする要素を引数にブロックを呼び出す。xpath を省略した場合は&quot;*&quot;が指定されたものと見なされる。

elems.each("a") {|elem| puts elem}
# <a num='1'/>
# <a num='2'/>
REXML::Elements#empty?

子要素がなかったら真を返す。

puts elems.empty?
# false
puts elems["b"].elements.empty?
# true
REXML::Elements#index(element)

elementが何番目の子要素かを返す。ここでも最初の子要素は0では なく1から始まる。もし、elementが子要素でなかった場合は-1を返 す。

puts elems.index(elems[3])
# 3
puts elems.index("dummy")
# -1
REXML::Elements#size

子要素の数を返す。

puts elems.size
# 4
REXML::Elements#to_a(xpath=nil)

xpathにマッチした要素の配列を返す。xpath を省略した場合は&quot;*&quot;が指定されたものと見なされる。

p elems.to_a.collect {|elem| elem.to_s}
# ["<a num='1'/>", "<a num='2'/>", "<b/>", "<c/>"]

REXML::Attributeクラス

REXML::Attributeクラスは属性ノードを表現しているクラスで、 REXML::NodeモジュールREXML::Namespaceモジュールをincludeしている。

ここでは、以下の記述は省略する。

source = "<a xmlns:hoge='http://hoge/' hoge:bar='bar'/>"
doc = REXML::Document.new(source)
attr = REXML::Attribute.new("attr", "val")
REXML::Attribute.new(attribute, element=nil)
REXML::Attribute.new(name, value=nil, element=nil)
REXML::Attribute.new(source, element=nil)

もし、第一引数がREXML::Attributeクラスのオブジェクトな ら一番目の形式 になる。この形式ではattributeのコピーを作る。REXMLのバグで elementは無視される。

第一引数がStringオブジェクトなら二番目の形式になる。 nameには属性名を、valueには参照が展開された属性値を指 定する。

第一引数がREXML::Sourceオブジェクトなら三番目の形式になる。 この形式ではsourceをパースして REXML::Attributeクラスのオブジェクトを生成する。

第一引数がそれ以外のオブジェクトの場合は例外が発生する。

elementには属するREXML::Elementクラスのオブジェ クトを指定する。 しかし、属性-&gt;要素という一方的な親子関係しか設定しないので、要素か らは属性が追加されたようには見えない。

e = REXML::Element.new("parent")
a = REXML::Attribute.new(attr, e)
puts e
# <parent/>
REXML::Attribute#==(attribute)

attributeREXML::Attributeクラスのオブジェクト で、属性名、属性 値共に等しければ真を返す。

puts REXML::Attribute.new("a", "b") == REXML::Attribute.new("a", "b")
# true
REXML::Attribute#clone

コピーを返す。

puts attr.clone
# val
REXML::Attribute#hash

属性名と属性値のハッシュ値を足したものを返す。

REXML::Attribute#namespace(prefix=nil)

prefixに関連付けられているネームスペース名を返す。もし、自分 自身がどのREXML::Elementクラスのオブジェクトにも属して いなかったら 例外が発生する。prefixを省略した場合は REXML::Attribute#prefixメソッドの戻り値が指定されたも のと見なされる。

a = REXML::Attribute.new("hoge:fuga", "fuga", doc.root)
puts a.namespace
# http://hoge/
REXML::Attribute#normalized=(normalized)

normalizedには、属性値内の参照が展開されたことにしたければ falseを、展開されていないことにしたければtrueを指定す る。

a = REXML::Attribute.new("name", "1 &lt;&#x3d; 3")
puts a.value
# 1 &lt;&#x3d; 3
a.normalized = true
puts a.value
# 1 <= 3
REXML::Attribute#prefix

接頭辞を返す。もし、接頭辞が設定されておらず、自分自身が属する REXML::Elementクラスのオブジェクトに接頭辞が設定されて いればそれを返す。接頭辞が設定されておらず、属する REXML::Elementクラスのオブジェク トもなければ空文字を返す。

a = REXML::Attribute.new("hoge:fuga", "fuga", doc.root)
puts a.prefix
# hoge
REXML::Attribute#remove

自分自身が属するREXML::Elementクラスのオブジェクトから 自分自身を削除する。もし、どのREXML::Elementクラスのオ ブジェクトにも属していないなら何もしない。

e = REXML::Element.new("elem")
a = REXML::Attribute.new("name", "value")
e.add_attribute(a)
puts e
# <elem name='value'/>
a.remove
puts e
# <elem/>
REXML::Attribute#to_s

参照が展開されていない属性値を返す。

例はREXML::Attribute#to_stringメソッドを参照。

REXML::Attribute#to_string

&quot;属性名=&apos;参照が展開されていない属性値&apos;&quot;という文字列を返す。

a = REXML::Attribute.new("name", "1 &lt;&#x3d; 3")
# REXML::Attribute.newで属性値を指定すると、参照が展開された
# 属性値とみなされるので、REXML::Attribute#cloneで
# REXML::Attributeオブジェクトを作り直す。
p a.clone.to_string
# "name='1 &lt;&#x3d; 3'"
p a.clone.to_s
# "1 &lt;&#x3d; 3"
p a.clone.value
# "1 <= 3"
REXML::Attribute#value

参照が展開された属性値を返す。

例はREXML::Attribute#to_stringREXML::Attribute#normalized=メソッドを参照。

REXML::Attribute#write(output)

outputREXML::Attribute#to_stringメソッドの戻り 値を書き出す。

REXML::Attributesクラス

REXML::AttributesクラスはHashクラスのサブクラスだ。 このクラスはREXML::Elementクラスで属性を管理するために使わ れており、主にREXML::Element#attributesメソッドでアクセス することになるだろう。

このクラスの削除系のメソッドは動作が怪しい。

ここでは、以下の記述は省略する。

source = <<-XML
<a xmlns:hoge='http://hoge/'
   xmlns:fuga='http://fuga'
   hoge:bar='hoge bar' bar='bar' attr='value'/>
XML
doc = REXML::Document.new(source)
attrs = doc.root.attributes
REXML::Attributes.new(element)

属する要素をelementに設定する。

REXML::Attributes#&lt;&lt;(attribute)

REXML::Attributes#addメソッドの別名。

REXML::Attributes#[name]

nameにマッチする属性の属性値を返す。マッチしなかったら nilを返す。

puts attrs["attr"]
# value
REXML::Attributes#[name] = value

属性名がnameの属性の属性値をvalueに設定する。もし、属 性名がnameの属性が存在しなかったら属性を追加する。

valueにnilを指定すると属性名がnameの属性を削除す る。

doc = REXML::Document.new(source)
attrs = doc.root.attributes
## []=
attrs["attr"] = "new value"
p attrs["attr"]
# "new value"
REXML::Attributes#add(attribute)

attributeにはREXML::Attributeクラスのオブジェク トを指定する。 REXML::Attributes#[attribute.name] = attributeと等価。

attrs.add(REXML::Attribute.new("fuga:bar", "fuga bar"))
puts doc.root
# <a xmlns:fuga='http://fuga' xmlns:hoge='http://hoge/'
#    bar='bar' fuga:bar='fuga bar' hoge:bar='hoge bar' attr='value'/>
REXML::Attributes#delete(attribute)

attributeにマッチする属性を削除する。マッチしなかったら何も しない。attributeには REXML::Attributeクラスのオブジェクトまたは属性名を指定する。 REXML::Attributeクラスのオブジェクトを指定した場合は &quot;#{attribute.prefix}:#{attribute.name}&quot;という属性名を指定し たとみなされる。

戻り値は親要素。

puts attrs.delete("attr")
# <a xmlns:fuga='http://fuga' xmlns:hoge='http://hoge/'
#    bar='bar' hoge:bar='hoge bar'/>
REXML::Attributes#delete_all(name)

ネームスペース名も含めて、nameに完全に一致する属性名を持つ属 性を削除する。

p attrs.delete_all("bar").collect {|attr| attr.to_string}
# ["bar='bar'"]
puts doc.root
# <a xmlns:fuga='http://fuga' xmlns:hoge='http://hoge/'
#    hoge:bar='hoge bar' attr='value'/>
REXML::Attributes#each(&amp;block)

各属性について属性名、属性値を引数にブロックを呼び出す。

tmp = []
attrs.each {|name, value| tmp << [name, value]}
p tmp
# [["xmlns:fuga", "http://fuga"], ["xmlns:hoge", "http://hoge/"],
#  ["bar", "bar"], ["hoge:bar", "hoge bar"], ["attr", "value"]]
REXML::Attributes#each_attribute(&amp;block)

各属性についてREXML::Attributeクラスのオブジェクトを引数に ブロックを呼び出す。

tmp = []
attrs.each_attribute {|attr| tmp << attr.to_string}
p tmp
# ["xmlns:fuga='http://fuga'", "xmlns:hoge='http://hoge/'",
#  "bar='bar'", "hoge:bar='hoge bar'", "attr='value'"]
REXML::Attributes#get_attribute(name)

nameにマッチする属性(REXML::Attributeクラスのオ ブジェクト)を 返す。マッチしなかったらnilを返す。マッチしなくてもDTDでデフォ ルト値が設定されている属性ならばデフォルト値が属性値の REXML::Attributeクラスのオブジェクトを返す。

p attrs.get_attribute("bar").to_string
# "bar='bar'"
REXML::Attributes#length

属性の数を返す。

puts attrs.length
# 5
REXML::Attributes#prefixes

接頭辞の配列を返す。

p attrs.prefixes
# ["fuga", "hoge"]
REXML::Attributes#size

REXML::Attributes#lengthメソッドの別名。