module RIO::IF::YAML

Public Instance Methods

document(*args,&block) click to toggle source

Select a single yaml document. See documents, #line and yaml.

# File lib/rio/if/yaml.rb, line 148
def document(*args,&block) target.document(*args,&block); self end
documents(*selectors,&block) click to toggle source

Select documents from a YAML file. See yaml and RIO::Doc::INTRO

# File lib/rio/if/yaml.rb, line 137
def documents(*selectors,&block) target.documents(*selectors,&block); self end
dump(obj) click to toggle source

Alias for #putobj!

# File lib/rio/if/yaml.rb, line 189
def dump(obj) target.dump(obj); self end
getobj() click to toggle source

Calls YAML.load.

Loads a single YAML object from the stream referenced by the Rio

rio('database.yml').yaml.getobj

See yaml and RIO::Doc::INTRO

# File lib/rio/if/yaml.rb, line 159
def getobj() target.getobj() end
load() click to toggle source

Calls YAML.load.

Loads a single YAML object from the stream referenced by the Rio

rio('database.yml').yaml.load

See yaml and RIO::Doc::INTRO

# File lib/rio/if/yaml.rb, line 169
def load() target.load() end
object(*args,&block) click to toggle source

Select a single object. See objects, #line and yaml.

# File lib/rio/if/yaml.rb, line 144
def object(*args,&block) target.object(*args,&block); self end
objects(*selectors,&block) click to toggle source

Select objects from a YAML file. See yaml and RIO::Doc::INTRO

# File lib/rio/if/yaml.rb, line 129
def objects(*selectors,&block) target.objects(*selectors,&block); self end
putobj(obj) click to toggle source

Calls YAML.dump, leaving the Rio open.

# File lib/rio/if/yaml.rb, line 176
def putobj(obj) target.putobj(obj); self end
putobj!(obj) click to toggle source

Dumps an object to a Rio as with #putobj, and closes the Rio.

rio('afile.yaml').yaml.putobj!(anobject)

is identical to

rio('afile.yaml').yaml.putobj(anobject).close
# File lib/rio/if/yaml.rb, line 186
def putobj!(obj) target.putobj!(obj); self end
skipdocuments(*selectors,&block) click to toggle source

Reject documents from a YAML file. Calls #skiprows. See yaml and RIO::Doc::INTRO

# File lib/rio/if/yaml.rb, line 141
def skipdocuments(*selectors,&block) target.skipdocuments(*selectors,&block); self end
skipobjects(*selectors,&block) click to toggle source

Reject objects from a YAML file. Calls #skiprecords. See yaml and RIO::Doc::INTRO

# File lib/rio/if/yaml.rb, line 133
def skipobjects(*selectors,&block) target.skipobjects(*selectors,&block); self end
yaml(&block) click to toggle source

Puts a Rio in YAML mode.

Rio uses the YAML class from the Ruby standard library to provide support for reading and writing YAML files. Normally using (skip)records is identical to (skip)lines because while records only selects and does not specify the record-type, lines is the default.

The YAML extension distingishes between items selected using #records, #rows and #lines. Rio returns objects loaded via YAML#load when records or objects is used; returns the YAML text as a String when rows or documents is used; and returns lines as Strings as normal when lines is used. records is the default.

To read a single YAML document, Rio provides getobj and load. For example, consider the following partial 'database.yml' from the rails distribution:

development:
  adapter: mysql
  database: rails_development

test:
  adapter: mysql
  database: rails_test

To get the object represented in the yaml file:

rio('database.yml').yaml.load
   ==>{"development"=>{"adapter"=>"mysql", "database"=>"rails_development"}, 
       "test"=>{"adapter"=>"mysql", "database"=>"rails_test"}}

Or one could read parts of the file like so:

rio('database.yml').yaml.getobj['development']['database']
   ==>"rails_development"

Single objects can be written using putobj and putobj! which is aliased to dump

anobject = {
  'production' => {
    'adapter' => 'mysql',
    'database' => 'rails_production',
  }
}
rio('afile.yaml').yaml.dump(anobject)

Single objects can be written using #putrec (aliased to #putobj and #dump)

rio('afile.yaml').yaml.putobj(anobject)

Single objects can be loaded using #getrec (aliased to #getobj and #load)

anobject = rio('afile.yaml').yaml.getobj

A Rio in yaml-mode is just like any other Rio. And all the things you can do with any Rio come for free. They can be iterated over using #each and read into an array using #[] just like any other Rio. All the selection criteria are identical also.

Get the first three objects into an array:

array_of_objects = rio('afile.yaml').yaml[0..2]

Iterate over only YAML documents that are a kind_of ::Hash:

rio('afile.yaml').yaml(::Hash) {|ahash| ...}

This takes advantage of the fact that the default for matching records is ===

Selecting records using a Proc can be used as normal:

anarray = rio('afile.yaml').yaml(proc{|anobject| ...}).to_a

One could even use the copy operator to convert a CSV file to a YAML representation of the same data:

rio('afile.yaml').yaml < rio('afile.csv').csv
# File lib/rio/if/yaml.rb, line 118
def yaml(&block) 
  target.yaml(&block); 
  self 
end
yaml?() click to toggle source

Queries if the Rio is in yaml-mode. See yaml

# File lib/rio/if/yaml.rb, line 125
def yaml?() target.yaml? end