Ruby 1.9.3 リファレンスマニュアル > ライブラリ一覧 > syckライブラリ > Syckモジュール

module Syck

クラスの継承リスト: Syck

要約

yaml のバックエンドのためのモジュールです。

目次

特異メソッド

add_builtin_type add_domain_type add_private_type add_ruby_type detect_implicit dump dump_stream each_document load_documents each_node emitter generic_parser load load_file load_stream object_maker parse parse_documents parse_file parser quick_emit read_type_class resolver tagurize transfer try_implicit

モジュール関数

compile

定数

DefaultResolver GenericResolver

特異メソッド

add_builtin_type(type_tag) {|type, val| ...} -> nil[permalink][rdoc]

yaml.org,2002ドメインに属しているクラスをYAMLに追加し そのクラスを見つけたときの操作を指定します。

[PARAM] type_tag:

加えるクラスを指定する。

[PARAM] type:

YAMLドメインとクラスの文字列

[PARAM] val:

YAMLデータ構造

require 'yaml'

str1=<<EOT
--- !ruby.yaml.org,2002/Rational 5/6
EOT
str2=<<EOT
--- !yaml.org,2002/Rational 3/4
EOT

p YAML.load(str1)
#=> #<YAML::DomainType:0x2b07528 @type_id="Rational", @domain="ruby.yaml.org,2002", @value="5/6">

p YAML.load(str2)
#=> #<YAML::DomainType:0x2b0767c @type_id="Rational", @domain="yaml.org,2002", @value="3/4">

YAML.add_builtin_type("Rational"){|type, val|
  md = val.split(/\//)
  Rational.new!(md[0].to_i, md[1].to_i)
}

p YAML.load(str1)
#=> #<YAML::DomainType:0x2b06fec @type_id="Rational", @domain="ruby.yaml.org,2002", @value="5/6">
## 前回と変化なし

rt = YAML.load(str2)
p rt        # => Rational(3, 4)
p rt + 0.25 # => 1.0

add_domain_type(domain, type_tag) {|type, val| ...} -> nil[permalink][rdoc]

YAMLドメインに属しているクラスをYAMLに追加し、 そのクラスを見つけたときの操作を指定します。

[PARAM] domain:

YAMLのドメインを文字列で指定する。

[PARAM] type_tag:

加えるクラスを指定する。

[PARAM] type:

YAMLドメインとクラスの文字列

[PARAM] val:

YAMLデータ構造

require 'syck'
require 'yaml'

class Person
  attr_accessor :name, :age
end

str=<<EOT
--- !Qjitsu.com,2007-05-04/Person
name: eiji
age: 33
EOT

YAML.each_document(str){|obj|
  p obj
}
#=> #<YAML::DomainType:0x2b07974 @type_id="Person", @domain="Qjitsu.com,2007-05-04", @value={"name"=>"eiji", "age"=>33}>
#
YAML.add_domain_type( "Qjitsu.com,2007-05-04", "Person" ) { |type, val|
  YAML.object_maker( Person, val )
}
YAML.each_document(str){|obj|
  p obj
}
#=> #<Person:0x2b0762c @age=33, @name="eiji">

add_private_type(type_re) {|type, val| ...} -> nil[permalink][rdoc]

プライベートタイプのクラスをYAMLに追加し、 そのクラスを見つけたときの操作を指定します。

[PARAM] type_re:

プライベートタイプのクラスを文字列で指定します。

[PARAM] type:

YAMLドメインとクラスの文字列

[PARAM] val:

YAMLデータ構造

require 'syck'
require 'yaml'

class Person ; end

str1=<<EOT
--- !!Person
name: taro
country: Japan
capital: Tokyo
EOT

YAML.each_document(str1){|obj|
  p obj
}
#=> #<YAML::PrivateType:0x2b07a14 @type_id="Person", @value={"name"=>"taro", "country"=>"Japan", "capital"=>"Tokyo"}>
YAML.add_private_type("Person"){|type, val|
  YAML.object_maker(Person, val)
}
YAML.each_document(str1){|obj|
  p obj
}
#=> #<Person:0x2b07640 @country="Japan", @capital="Tokyo", @name="taro">

str2=<<EOT
--- !Qjitsu.com,2007-05-04/Person
name: eiji
age: 33
--- !!Person
name: ichiro
country: Japan
capital: Tokyo
EOT

YAML.each_document(str2){|obj|
  p obj
}
#=> #<YAML::DomainType:0x2b071a4 @type_id="Person", @domain="Qjitsu.com,2007-05-04", @value={"name"=>"eiji", "age"=>33}>
#=> #<Person:0x2b06eac @country="Japan", @capital="Tokyo", @name="ichiro">

add_ruby_type(type_tag) {|type, val| ...} -> nil[permalink][rdoc]

rubyタイプのクラスをYAMLに追加し、 そのクラスを見つけたときの操作を指定します。

[PARAM] type_tag:

rubyタイプのクラスを文字列で指定します。

[PARAM] type:

YAMLドメインとクラスの文字列

[PARAM] val:

YAMLデータ構造

require 'syck'
require 'yaml'

class Dog
  attr_accessor :name
  def initialize(name)
    @name = name
  end
end

str1=<<EOT
--- !ruby/Dog
name: pochi
--- !!Dog
age: 0.5
--- !Qjitsu.com,2007-05-06/Dog
preference: apple
EOT


YAML.add_ruby_type("Dog") do |type, val|
  YAML.object_maker(Dog, val)
end

YAML.each_document(str1){|dog|
  p dog.class
  p dog.respond_to?(:name)
}
#=> Dog
#=> true
#=> YAML::PrivateType
#=> false
#=> YAML::DomainType
#=> false

detect_implicit(val) -> String[permalink][rdoc]

タグを省略した値の型を判定します。

[PARAM] val:

判定される文字列を指定します。

require 'yaml'

p YAML.detect_implicit("")
# => "null"
p YAML.detect_implicit("Cat")
# => "str"
p YAML.detect_implicit("true")
# => "bool#yes"
p YAML.detect_implicit("10")
# => "int"
p YAML.detect_implicit("0x10")
# => "int#hex"

dump(obj, io = nil) -> String | IO[permalink][rdoc]

与えられた obj を YAML フォーマットに変換し、io に書き込みます。io を返 します。io が与えられていない場合は、YAML フォーマットの文字列を返しま す。

[PARAM] obj:

YAMLフォーマットに変換されるオブジェクト

[PARAM] io:

出力先のIOオブジェクト

YAML.dump( ['badger', 'elephant', 'tiger'],
           File.open('sample.yml', 'w')    )

dump_stream(*objs) -> String[permalink][rdoc]

与えられた objs を順に YAML フォーマットに変換していき、一つの文字列にまとめたものを返します。

[PARAM] objs:

YAMLフォーマットに変換されるオブジェクト

require "yaml"
puts YAML.dump_stream( "hoge\nfoo", [1,2], {"foo" => "bar"} )
--- |-
hoge
foo
---
- 1
- 2
---
foo: bar

each_document(io) {|obj| ...} -> nil[permalink][rdoc]

load_documents(io) {|obj| ...} -> nil

与えられた io から YAML フォーマットの文書をすべて順に読み込み Ruby のオブジェクトに変換し、 生成したオブジェクトを引数としてブロックを評価していきます。

[PARAM] io:

YAMLフォーマットの文書の読み込み先のIOオブジェクト

# sample.yml
- apple
- banana
- carrot
---
foo: bar

#!/usr/bin/env ruby
require "yaml"
File.open( 'sample.yml' ) do |io|
  YAML.load_documents(io){|y|
    p y
  }
end
#=>   ["apple", "banana", "carrot"]
#=>   {"foo"=>"bar"}

[注意] ブロックを指定しないと NoMethodError が発生する事に注意してください。

each_node(io) {|obj| ...} -> nil[permalink][rdoc]

与えられた io から YAML フォーマットの文書をすべて順に読み込み Syck::Map オブジェクトに変換し、 生成したオブジェクトを引数としてブロックを評価していきます。

[PARAM] io:

YAML フォーマットの文書の IO オブジェクト

food:
 - apple
 - banana
 - carrot
---
foo: bar
# end of test.yml

require 'syck'
require 'yaml'

File.open( 'test.yml' ) do |io|
  YAML.each_node(io) do |y|
    p y.transform
  end
end
#=> {"food"=>["apple", "banana", "carrot"]}
#=> {"foo"=>"bar"}

emitter -> Syck::Emitter[permalink][rdoc]

YAML を出力するためのオブジェクトを返します。

generic_parser -> Syck::Parser[permalink][rdoc]

YAML パーサを返します。ただし、YAML.parser とは異なり、リゾルバに Syck::GenericResolver が指定されています。

[SEE_ALSO] YAML.parser

load(io) -> object[permalink][rdoc]

load(str) -> object

YAML フォーマットの文書を読み込み Ruby のオブジェクトを生成して返します。 引数として IO オブジェクトと文字列を受け付けます。 io や 文字列が複数の YAML ドキュメントを含んでいても、最初のものしか Ruby のオブジェクトに変換しません。

[PARAM] io:

YAMLフォーマットの文書の読み込み先のIOオブジェクト

[PARAM] str:

YAMLフォーマットの文書の読み込み先の文字列

$ ruby-1.8 -ryaml -e '
p YAML.load(<<HERE)
- apple
- banana
- carrot
---
foo: bar
HERE
'
["apple", "banana", "carrot"]

load_file(file) -> object[permalink][rdoc]

与えられた名前のファイルから YAML フォーマットの文書を読み込み Ruby のオブジェクトを生成して返します。 ファイルが複数の YAML ドキュメントを含んでいても、 最初のものしか Ruby のオブジェクトに変換しません。

[PARAM] file:

YAMLフォーマットのファイル

---
- Monday
-
 - 国語
 - 算数
 - 理科
 - 社会
 - 体育
---
- Friday
-
 - 体育
 - 算数
 - 理科
 - 国語
 - 社会
#end of jikanwari.yaml

require 'yaml'

puts YAML.load_file('jikanwari.yaml').join(",")

#=> Monday,国語,算数,理科,社会,体育

load_stream(io) -> object[permalink][rdoc]

与えられた io から YAML フォーマットの文書を すべて順に読み込んで Ruby のオブジェクトに変換していき、 それらオブジェクトを含んだ Syck::Stream を返します。

[PARAM] io:

YAML フォーマットの文書のIOオブジェクトもしくは文字列

require 'syck'
require 'yaml'

class Dog
  attr_accessor :name
  def initialize(name)
    @name = name
  end
end

str1=<<EOT
--- !ruby/Dog
name: pochi
--- !!Dog
age: 0.5
EOT

YAML.add_ruby_type("Dog") do |type, val|
  Dog.new(val["name"])
end

ys = YAML.load_stream(str1)
p ys
#=> #<YAML::Stream:0x2b079d8 @options={}, @documents=[#<Dog:0x2b079c4 @name="pochi">, #<YAML::PrivateType:0x2b07780 @value={"age"=>0.5}, @type_id="Dog">]>
ys.edit(1, Dog.new("tama"))
p ys.documents
#=> [#<Dog:0x2b079b0 @name="pochi">, #<Dog:0x2b0762c @name="tama">]

object_maker(obj_class, val) -> object[permalink][rdoc]

与えられたobj_class クラスに、valハッシュをインスタンス変数として追加し obj_classクラスのインスタンスを生成して返します。

[PARAM] obj_class:

クラスを指定します。

[PARAM] val:

Hash を指定します。obj_classのインスタンス変数作成に使 用されます。

[EXCEPTION] YAML::Error:

val に Hash を指定しなかった場合に発生します。

require 'yaml'

class Cat; end

YAML.load_documents(DATA){|y|
  p YAML.object_maker(Cat, y)
}

__END__
name: taro
age: 13
---
name: jiro
age: 23
---
name: saburo
age: 8
# end of sample

結果
#=> #<Cat:0xb7ccb174 @name="taro", @age=13>
#=> #<Cat:0xb7ccafa8 @name="jiro", @age=23>
#=> #<Cat:0xb7ccaad0 @name="saburo", @age=8>

parse(io) -> Syck::Node[permalink][rdoc]

与えられた io から YAML フォーマットの文書をパースし Syck::Node かそのサブクラスのオブジェクトに変換します。 複数のドキュメントを読み込む場合は、YAML.parse_documents(実体は Syck.parse_documents) を使用します。

[PARAM] io:

YAMLフォーマットのIOオブジェクトもしくは文字列

#!/usr/bin/env ruby

require 'syck'
require 'yaml'

doc = YAML.parse(DATA)
doc.search("//name").each {|node|
  p node
}

__END__
cat:
 - name: taro
   age: 7
 - name: jiro
   age: 23
---
dog:
 shiba:
  - name: goro
    age: 3
  - name: rokuro
    age: 1
# end of sample
#=> "/cat/0/name"
#=> "/cat/1/name"
# dog は読み込まない

parse_documents(io) {|obj| ...} -> nil[permalink][rdoc]

与えられた io から YAML フォーマットの文書をパースし Syck::Nodeオブジェクトに変換し、 生成したオブジェクトを引数としてブロックを評価していきます。

[PARAM] io:

YAML フォーマットの文書の IO オブジェクトもしくは文字列

require 'syck'
require 'yaml'

YAML.parse_documents(DATA){|doc|
  doc.search('/dog//name').each {|node|
    p node
  }
  p "-->"
}

__END__
cat:
 - name: taro
   age: 7
 - name: jiro
   age: 23
---
dog:
 shiba:
  - name: goro
    age: 3
  - name: rokuro
    age: 1
# end of sample

#=> "-->"
#=> "/dog/shiba/0/name"
#=> "/dog/shiba/1/name"
#=> "-->"

[注意] ブロックを指定しないと NoMethodError が発生する事に注意してください。

parse_file(file_path) -> Syck::Node[permalink][rdoc]

file_pathのファイルから一つのYAMLドキュメントをパースし、 Syck::Nodeオブジェクトを返します。

[PARAM] file_path:

YAMLドキュメントが書かれたファイルへのパスを文字列で指定する

cat:
 - name: taro
   age: 7
 - name: jiro
   age: 23
---
dog:
 shiba:
  - name: goro
    age: 3
  - name: rokuro
    age: 1
# end of sample.yaml

require 'yaml'

tree = YAML.parse_file("sample.yaml")
p tree.transform

#=> {"cat"=>[{"name"=>"taro", "age"=>7}, {"name"=>"jiro", "age"=>23}]}

parser -> Syck::Parser[permalink][rdoc]

YAML パーサを返します。

[SEE_ALSO] YAML.generic_parser

quick_emit(oid, opts={}) {|obj| ...} -> String[permalink][rdoc]

ライブラリ内部で使用します。

read_type_class(type, obj_class) -> [String, Class][permalink][rdoc]

ライブラリ内部で使用します。

resolver -> Syck::DefaultResolver[permalink][rdoc]

タグ URI との関連付けを解決するリゾルバを返します。

tagurize(val) -> String[permalink][rdoc]

val で指定したタグを元にタグ URI を作成します。

[PARAM] val:

タグを文字列で指定します。

例:

require 'yaml'
YAML.tagurize("str")      # => "tag:yaml.org,2002:str"
YAML.tagurize("ruby/sym") # => "tag:ruby.yaml.org,2002:sym"
YAML.tagurize("tag:ruby.yaml.org,2002:sym")
# => "tag:ruby.yaml.org,2002:sym"

transfer(type_id, obj) -> object[permalink][rdoc]

ライブラリ内部で使用します。

try_implicit(obj) -> object[permalink][rdoc]

ライブラリ内部で使用します。

モジュール関数

compile(io)[permalink][rdoc]

[TODO]

Convert YAML to bytecode

定数

DefaultResolver -> YAML::Syck::Resolver[permalink][rdoc]

[TODO]

GenericResolver -> YAML::Syck::Resolver[permalink][rdoc]

[TODO]